home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 3 / Amiga Tools 3.iso / terminal / term / extras / source / term-source.lha / termConfig.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-09-26  |  85.4 KB  |  3,625 lines
  1. /*
  2. **    termConfig.c
  3. **
  4. **    Configuration processing routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #include "termGlobal.h"
  13.  
  14.     /* Reset routine function pointer. */
  15.  
  16. typedef VOID        (* RESET)(APTR,STRPTR);
  17.  
  18.     /* Local routines. */
  19.  
  20. STATIC BYTE        ReadSystemPrefs(STRPTR Name,ULONG ID,APTR Data,LONG Size,LONG Count);
  21.  
  22. STATIC VOID        ResetSerialConfig(struct SerialSettings *SerialConfig);
  23. STATIC VOID        ResetModem(struct ModemSettings *ModemConfig);
  24. STATIC VOID        ResetScreen(struct ScreenSettings *ScreenConfig);
  25. STATIC VOID        ResetTerminal(struct TerminalSettings *TerminalConfig);
  26. STATIC VOID        ResetEmulation(struct EmulationSettings *EmulationConfig);
  27. STATIC VOID        ResetClip(struct ClipSettings *ClipConfig);
  28. STATIC VOID        ResetCapture(struct CaptureSettings *CaptureConfig);
  29. STATIC VOID        ResetFile(struct FileSettings *FileConfig,STRPTR PathBuffer);
  30. STATIC VOID        ResetPath(struct PathSettings *PathConfig,STRPTR PathBuffer);
  31. STATIC VOID        ResetMisc(struct MiscSettings *MiscConfig);
  32. STATIC VOID        ResetCommand(struct CommandSettings *CommandConfig);
  33. STATIC VOID        ResetTransfer(struct TransferSettings *TransferConfig,STRPTR DefaultLib);
  34. STATIC VOID        ResetTranslationFile(STRPTR Arg,STRPTR PathBuffer);
  35. STATIC VOID        ResetMacroFile(STRPTR Arg,STRPTR PathBuffer);
  36. STATIC VOID        ResetCursorFile(STRPTR Arg,STRPTR PathBuffer);
  37. STATIC VOID        ResetFastMacroFile(STRPTR Arg,STRPTR PathBuffer);
  38.  
  39. STATIC BYTE        WriteConfigChunk(struct IFFHandle *Handle,struct Configuration *Config,BYTE Type,APTR TempBuffer,STRPTR Password);
  40. STATIC BYTE        WriteConfigChunks(struct IFFHandle *Handle,struct Configuration *Config,APTR TempBuffer,STRPTR Password);
  41. STATIC UBYTE    IsConfigChunk(ULONG ID);
  42. STATIC BYTE        ReadConfigChunk(struct IFFHandle *Handle,struct Configuration *Config,UBYTE Type,LONG Len,STRPTR Password);
  43.  
  44. STATIC UWORD SizeTable[] =
  45. {
  46.     sizeof(struct SerialSettings),
  47.     sizeof(struct ModemSettings),
  48.     sizeof(struct CommandSettings),
  49.     sizeof(struct ScreenSettings),
  50.     sizeof(struct TerminalSettings),
  51.     sizeof(struct PathSettings),
  52.     sizeof(struct MiscSettings),
  53.     sizeof(struct ClipSettings),
  54.     sizeof(struct CaptureSettings),
  55.     sizeof(struct FileSettings),
  56.     sizeof(struct EmulationSettings),
  57.     sizeof(struct TransferSettings),
  58.     MAX_FILENAME_LENGTH,                // Translation file name
  59.     MAX_FILENAME_LENGTH,                // Macro file name
  60.     MAX_FILENAME_LENGTH,                // Cursor file name
  61.     MAX_FILENAME_LENGTH,                // Fast macro file name
  62. };
  63.  
  64. STATIC RESET ResetTable[] =
  65. {
  66.     (RESET)ResetSerialConfig,
  67.     (RESET)ResetModem,
  68.     (RESET)ResetCommand,
  69.     (RESET)ResetScreen,
  70.     (RESET)ResetTerminal,
  71.     ResetPath,
  72.     (RESET)ResetMisc,
  73.     (RESET)ResetClip,
  74.     (RESET)ResetCapture,
  75.     ResetFile,
  76.     (RESET)ResetEmulation,
  77.     ResetTransfer,
  78.     (RESET)ResetTranslationFile,
  79.     (RESET)ResetMacroFile,
  80.     (RESET)ResetCursorFile,
  81.     (RESET)ResetFastMacroFile
  82. };
  83.  
  84. STATIC ULONG TypeTable[] =
  85. {
  86.     ID_SERL,
  87.     ID_MODM,
  88.     ID_COMD,
  89.     ID_SCRN,
  90.     ID_TRML,
  91.     ID_PATH,
  92.     ID_MISC,
  93.     ID_CLIP,
  94.     ID_CPTR,
  95.     ID_FILE,
  96.     ID_EMLN,
  97.     ID_XFER,
  98.     ID_XLNM,
  99.     ID_MFNM,
  100.     ID_CRNM,
  101.     ID_FMNM
  102. };
  103.  
  104. #define NUM_STOPS (sizeof(Stops) / (2 * sizeof(ULONG)))
  105.  
  106. STATIC LONG Stops[] =
  107. {
  108.     ID_TERM,ID_CAT,
  109.     ID_TERM,ID_VERS,
  110.     ID_TERM,ID_DIAL,
  111.     ID_TERM,ID_DATE,
  112.     ID_TERM,ID_PHON,
  113.     ID_TERM,ID_PSWD,
  114.  
  115.     ID_TERM,ID_SERL,
  116.     ID_TERM,ID_MODM,
  117.     ID_TERM,ID_COMD,
  118.     ID_TERM,ID_SCRN,
  119.     ID_TERM,ID_TRML,
  120.     ID_TERM,ID_PATH,
  121.     ID_TERM,ID_MISC,
  122.     ID_TERM,ID_CLIP,
  123.     ID_TERM,ID_CPTR,
  124.     ID_TERM,ID_FILE,
  125.     ID_TERM,ID_EMLN,
  126.     ID_TERM,ID_XFER,
  127.     ID_TERM,ID_WINF,
  128.     ID_TERM,ID_GRUP,
  129.     ID_TERM,ID_XLNM,
  130.     ID_TERM,ID_MFNM,
  131.     ID_TERM,ID_CRNM,
  132.     ID_TERM,ID_FMNM
  133. };
  134.  
  135. STATIC BYTE                        FontPrefsRead        = FALSE,
  136.                                 FontPrefsReadFailed    = FALSE;
  137. STATIC struct FontPrefs            FontPrefs[3];
  138.  
  139. STATIC BYTE                        ScreenModePrefsRead            = FALSE,
  140.                                 ScreenModePrefsReadFailed    = FALSE;
  141. STATIC struct ScreenModePrefs    ScreenModePrefs;
  142.  
  143. enum    {    CR_IGNORE,CR_ASCR,CR_ASCRLF };
  144. enum    {    LF_IGNORE,LF_ASLF,LF_ASLFCR };
  145.  
  146. VOID __regargs
  147. FinalFix(struct Configuration *Config,BOOLEAN IsPhonebook,LONG Version,LONG Revision)
  148. {
  149.     if(Config)
  150.     {
  151.         if(Version < 4 || (Version == 4 && Revision < 3))
  152.         {
  153.             if(Config -> TransferConfig && Config -> MiscConfig)
  154.             {
  155.                 Config -> TransferConfig -> OverridePath    = Config -> MiscConfig -> OverridePath;
  156.                 Config -> TransferConfig -> SetArchivedBit    = Config -> MiscConfig -> SetArchivedBit;
  157.                 Config -> TransferConfig -> IdentifyFiles    = Config -> MiscConfig -> IdentifyFiles;
  158.                 Config -> TransferConfig -> TransferIcons    = Config -> MiscConfig -> TransferIcons;
  159.                 Config -> TransferConfig -> PerfMeter        = Config -> MiscConfig -> PerfMeter;
  160.                 Config -> TransferConfig -> HideUploadIcon    = Config -> MiscConfig -> HideUploadIcon;
  161.             }
  162.         }
  163.  
  164.         if(Version < 4 || (Version == 4 && Revision < 4))
  165.         {
  166.             if(Config -> TerminalConfig && Config -> MiscConfig)
  167.                 Config -> MiscConfig -> AlertMode = Config -> TerminalConfig -> AlertMode;
  168.         }
  169.     }
  170. }
  171.  
  172. VOID __regargs
  173. FixOldConfig(struct Configuration *Config,UBYTE ConfigChunkType,BOOLEAN IsPhonebook,LONG Version,LONG Revision)
  174. {
  175.     if((Version == 3 && Revision < 6) || Version < 3)
  176.     {
  177.         if(ConfigChunkType == PREF_CLIP)
  178.             Config -> ClipConfig -> ConvertLF = TRUE;
  179.  
  180.         if(ConfigChunkType == PREF_SERIAL)
  181.             Config -> SerialConfig -> UseOwnDevUnit = TRUE;
  182.  
  183.         if(ConfigChunkType == PREF_MISC)
  184.             Config -> MiscConfig -> ProtectiveMode = TRUE;
  185.  
  186.         if(ConfigChunkType == PREF_SCREEN)
  187.         {
  188.             Config -> ScreenConfig -> UsePens    = TRUE;
  189.             Config -> ScreenConfig -> Depth        = 0;
  190.             Config -> ScreenConfig -> PenColourMode    = 42;    // Avoid trouble
  191.         }
  192.  
  193.         if(ConfigChunkType == PREF_TRANSFER)
  194.         {
  195.             WORD i;
  196.  
  197.             Config -> TransferConfig -> MangleFileNames = FALSE;
  198.  
  199.             if(Config -> TransferConfig -> ASCIIUploadLibrary[0])
  200.                 Config -> TransferConfig -> ASCIIUploadType = XFER_XPR;
  201.  
  202.             if(Config -> TransferConfig -> ASCIIDownloadLibrary[0])
  203.                 Config -> TransferConfig -> ASCIIDownloadType = XFER_XPR;
  204.  
  205.             if(Config -> TransferConfig -> TextUploadLibrary[0])
  206.                 Config -> TransferConfig -> TextUploadType = XFER_XPR;
  207.  
  208.             if(Config -> TransferConfig -> TextDownloadLibrary[0])
  209.                 Config -> TransferConfig -> TextDownloadType = XFER_XPR;
  210.  
  211.             if(Config -> TransferConfig -> BinaryUploadLibrary[0])
  212.                 Config -> TransferConfig -> BinaryUploadType = XFER_XPR;
  213.  
  214.             if(Config -> TransferConfig -> BinaryDownloadLibrary[0])
  215.                 Config -> TransferConfig -> BinaryDownloadType = XFER_XPR;
  216.  
  217.             for(i = 0 ; i < strlen(Config -> TransferConfig -> DefaultLibrary) - 6 ; i++)
  218.             {
  219.                 if(!Strnicmp(&Config -> TransferConfig -> DefaultLibrary[i],"zmodem",6))
  220.                 {
  221.                     strcpy(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature,"*\030B01");
  222.  
  223.                     Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Length = strlen(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature);
  224.  
  225.                     break;
  226.                 }
  227.             }
  228.         }
  229.  
  230.         if(ConfigChunkType == PREF_MODEM)
  231.             Config -> ModemConfig -> AbortHangsUp = FALSE;
  232.  
  233.         if(ConfigChunkType == PREF_COMMAND && IsPhonebook)
  234.         {
  235.             strcpy(Config -> CommandConfig -> LoginMacro,Config -> CommandConfig -> StartupMacro);
  236.  
  237.             memset(Config -> CommandConfig -> StartupMacro,0,sizeof(Config -> CommandConfig -> StartupMacro));
  238.         }
  239.  
  240.         if(ConfigChunkType == PREF_CAPTURE)
  241.             Config -> CaptureConfig -> SearchHistory = 10;
  242.  
  243.         if(ConfigChunkType == PREF_EMULATION)
  244.         {
  245.             if(Config -> EmulationConfig -> DestructiveBackspace < 0 || Config -> EmulationConfig -> DestructiveBackspace > 2)
  246.                 Config -> EmulationConfig -> DestructiveBackspace = 1;
  247.         }
  248.     }
  249.  
  250.     if((Version == 4 && Revision < 1) || Version < 4)
  251.     {
  252.         if(ConfigChunkType == PREF_CLIP)
  253.             Config -> ClipConfig -> ConvertLF = TRUE;
  254.  
  255.         if(ConfigChunkType == PREF_SERIAL)
  256.         {
  257.             Config -> SerialConfig -> xONxOFF    = FALSE;
  258.             Config -> SerialConfig -> PassThrough    = TRUE;
  259.         }
  260.  
  261.         if(ConfigChunkType == PREF_MISC)
  262.             Config -> MiscConfig -> ProtectiveMode = TRUE;
  263.  
  264.         if(ConfigChunkType == PREF_MODEM)
  265.         {
  266.             Config -> ModemConfig -> RedialDelay    = (Config -> ModemConfig -> RedialDelay / 6) * 60 + (Config -> ModemConfig -> RedialDelay % 6) * 10;
  267.             Config -> ModemConfig -> TimeToConnect    = (Config -> ModemConfig -> TimeToConnect / 6) * 60 + (Config -> ModemConfig -> TimeToConnect % 6) * 10;
  268.             Config -> ModemConfig -> VerboseDialing    = FALSE;
  269.         }
  270.  
  271.         if(ConfigChunkType == PREF_TERMINAL)
  272.         {
  273.             switch(Config -> TerminalConfig -> SendCR)
  274.             {
  275.                 case CR_IGNORE:
  276.  
  277.                     Config -> TerminalConfig -> SendCR = EOL_IGNORE;
  278.                     break;
  279.  
  280.                 case CR_ASCR:
  281.  
  282.                     Config -> TerminalConfig -> SendCR = EOL_CR;
  283.                     break;
  284.  
  285.                 case CR_ASCRLF:
  286.  
  287.                     Config -> TerminalConfig -> SendCR = EOL_CRLF;
  288.                     break;
  289.             }
  290.  
  291.             switch(Config -> TerminalConfig -> ReceiveCR)
  292.             {
  293.                 case CR_IGNORE:
  294.  
  295.                     Config -> TerminalConfig -> ReceiveCR = EOL_IGNORE;
  296.                     break;
  297.  
  298.                 case CR_ASCR:
  299.  
  300.                     Config -> TerminalConfig -> ReceiveCR = EOL_CR;
  301.                     break;
  302.  
  303.                 case CR_ASCRLF:
  304.  
  305.                     Config -> TerminalConfig -> ReceiveCR = EOL_CRLF;
  306.                     break;
  307.             }
  308.  
  309.             switch(Config -> TerminalConfig -> SendLF)
  310.             {
  311.                 case LF_IGNORE:
  312.  
  313.                     Config -> TerminalConfig -> SendLF = EOL_IGNORE;
  314.                     break;
  315.  
  316.                 case LF_ASLF:
  317.  
  318.                     Config -> TerminalConfig -> SendLF = EOL_LF;
  319.                     break;
  320.  
  321.                 case LF_ASLFCR:
  322.  
  323.                     Config -> TerminalConfig -> SendLF = EOL_LFCR;
  324.                     break;
  325.             }
  326.  
  327.             switch(Config -> TerminalConfig -> ReceiveLF)
  328.             {
  329.                 case LF_IGNORE:
  330.  
  331.                     Config -> TerminalConfig -> ReceiveLF = EOL_IGNORE;
  332.                     break;
  333.  
  334.                 case LF_ASLF:
  335.  
  336.                     Config -> TerminalConfig -> ReceiveLF = EOL_LF;
  337.                     break;
  338.  
  339.                 case LF_ASLFCR:
  340.  
  341.                     Config -> TerminalConfig -> ReceiveLF = EOL_LFCR;
  342.                     break;
  343.             }
  344.         }
  345.  
  346.         if(ConfigChunkType == PREF_TRANSFER)
  347.         {
  348.             WORD i;
  349.  
  350.             if(Config -> TransferConfig -> ASCIIUploadLibrary[0])
  351.                 Config -> TransferConfig -> ASCIIUploadType = XFER_XPR;
  352.  
  353.             if(Config -> TransferConfig -> ASCIIDownloadLibrary[0])
  354.                 Config -> TransferConfig -> ASCIIDownloadType = XFER_XPR;
  355.  
  356.             if(Config -> TransferConfig -> TextUploadLibrary[0])
  357.                 Config -> TransferConfig -> TextUploadType = XFER_XPR;
  358.  
  359.             if(Config -> TransferConfig -> TextDownloadLibrary[0])
  360.                 Config -> TransferConfig -> TextDownloadType = XFER_XPR;
  361.  
  362.             if(Config -> TransferConfig -> BinaryUploadLibrary[0])
  363.                 Config -> TransferConfig -> BinaryUploadType = XFER_XPR;
  364.  
  365.             if(Config -> TransferConfig -> BinaryDownloadLibrary[0])
  366.                 Config -> TransferConfig -> BinaryDownloadType = XFER_XPR;
  367.  
  368.             for(i = 0 ; i < strlen(Config -> TransferConfig -> DefaultLibrary) - 6 ; i++)
  369.             {
  370.                 if(!Strnicmp(&Config -> TransferConfig -> DefaultLibrary[i],"zmodem",6))
  371.                 {
  372.                     strcpy(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature,"*\030B01");
  373.  
  374.                     Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Length = strlen(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature);
  375.  
  376.                     break;
  377.                 }
  378.             }
  379.  
  380.             switch(Config -> TransferConfig -> SendCR)
  381.             {
  382.                 case CR_IGNORE:
  383.  
  384.                     Config -> TransferConfig -> SendCR = EOL_IGNORE;
  385.                     break;
  386.  
  387.                 case CR_ASCR:
  388.  
  389.                     Config -> TransferConfig -> SendCR = EOL_CR;
  390.                     break;
  391.  
  392.                 case CR_ASCRLF:
  393.  
  394.                     Config -> TransferConfig -> SendCR = EOL_CRLF;
  395.                     break;
  396.             }
  397.  
  398.             switch(Config -> TransferConfig -> ReceiveCR)
  399.             {
  400.                 case CR_IGNORE:
  401.  
  402.                     Config -> TransferConfig -> ReceiveCR = EOL_IGNORE;
  403.                     break;
  404.  
  405.                 case CR_ASCR:
  406.  
  407.                     Config -> TransferConfig -> ReceiveCR = EOL_CR;
  408.                     break;
  409.  
  410.                 case CR_ASCRLF:
  411.  
  412.                     Config -> TransferConfig -> ReceiveCR = EOL_CRLF;
  413.                     break;
  414.             }
  415.  
  416.             switch(Config -> TransferConfig -> SendLF)
  417.             {
  418.                 case LF_IGNORE:
  419.  
  420.                     Config -> TransferConfig -> SendLF = EOL_IGNORE;
  421.                     break;
  422.  
  423.                 case LF_ASLF:
  424.  
  425.                     Config -> TransferConfig -> SendLF = EOL_LF;
  426.                     break;
  427.  
  428.                 case LF_ASLFCR:
  429.  
  430.                     Config -> TransferConfig -> SendLF = EOL_LFCR;
  431.                     break;
  432.             }
  433.  
  434.             switch(Config -> TransferConfig -> ReceiveLF)
  435.             {
  436.                 case LF_IGNORE:
  437.  
  438.                     Config -> TransferConfig -> ReceiveLF = EOL_IGNORE;
  439.                     break;
  440.  
  441.                 case LF_ASLF:
  442.  
  443.                     Config -> TransferConfig -> ReceiveLF = EOL_LF;
  444.                     break;
  445.  
  446.                 case LF_ASLFCR:
  447.  
  448.                     Config -> TransferConfig -> ReceiveLF = EOL_LFCR;
  449.                     break;
  450.             }
  451.         }
  452.     }
  453.  
  454.     if(Version == 4 && Revision < 3)
  455.     {
  456.         if(ConfigChunkType == PREF_CLIP)
  457.             Config -> ClipConfig -> ConvertLF = TRUE;
  458.  
  459.         if(ConfigChunkType == PREF_SERIAL)
  460.         {
  461.             Config -> SerialConfig -> xONxOFF    = FALSE;
  462.             Config -> SerialConfig -> PassThrough    = TRUE;
  463.         }
  464.  
  465.         if(ConfigChunkType == PREF_MISC)
  466.             Config -> MiscConfig -> ProtectiveMode = TRUE;
  467.  
  468.         if(ConfigChunkType == PREF_TRANSFER)
  469.         {
  470.             WORD i;
  471.  
  472.             for(i = 0 ; i < strlen(Config -> TransferConfig -> DefaultLibrary) - 6 ; i++)
  473.             {
  474.                 if(!Strnicmp(&Config -> TransferConfig -> DefaultLibrary[i],"zmodem",6))
  475.                 {
  476.                     strcpy(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature,"*\030B01");
  477.  
  478.                     Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Length = strlen(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature);
  479.  
  480.                     break;
  481.                 }
  482.             }
  483.  
  484.             if(Config -> TransferConfig -> ASCIIUploadLibrary[0])
  485.                 Config -> TransferConfig -> ASCIIUploadType = XFER_XPR;
  486.  
  487.             if(Config -> TransferConfig -> ASCIIDownloadLibrary[0])
  488.                 Config -> TransferConfig -> ASCIIDownloadType = XFER_XPR;
  489.  
  490.             if(Config -> TransferConfig -> InternalASCIIUpload)
  491.                 Config -> TransferConfig -> ASCIIUploadType = XFER_INTERNAL;
  492.  
  493.             if(Config -> TransferConfig -> InternalASCIIDownload)
  494.                 Config -> TransferConfig -> ASCIIDownloadType = XFER_INTERNAL;
  495.  
  496.             if(Config -> TransferConfig -> TextUploadLibrary[0])
  497.                 Config -> TransferConfig -> TextUploadType = XFER_XPR;
  498.  
  499.             if(Config -> TransferConfig -> TextDownloadLibrary[0])
  500.                 Config -> TransferConfig -> TextDownloadType = XFER_XPR;
  501.  
  502.             if(Config -> TransferConfig -> BinaryUploadLibrary[0])
  503.                 Config -> TransferConfig -> BinaryUploadType = XFER_XPR;
  504.  
  505.             if(Config -> TransferConfig -> BinaryDownloadLibrary[0])
  506.                 Config -> TransferConfig -> BinaryDownloadType = XFER_XPR;
  507.         }
  508.     }
  509. }
  510.  
  511. VOID __regargs
  512. FixScreenPens(struct ScreenSettings *ScreenConfig)
  513. {
  514.     WORD i,Count;
  515.  
  516.     for(Count = 0, i = DETAILPEN ; i <= BARTRIMPEN ; i++)
  517.     {
  518.         if(ScreenConfig -> PenArray[i])
  519.             Count++;
  520.     }
  521.  
  522.     if(!Count)
  523.         ScreenConfig -> UsePens = TRUE;
  524. }
  525.  
  526.     /* ReadSystemPrefs():
  527.      *
  528.      *    Reads the system preferences settings.
  529.      */
  530.  
  531. STATIC BYTE
  532. ReadSystemPrefs(STRPTR Name,ULONG ID,APTR Data,LONG Size,LONG Count)
  533. {
  534.     struct IFFHandle    *Handle;
  535.     BYTE                 Success = FALSE;
  536.     LONG                 Error = 0;
  537.  
  538.         /* Allocate an IFF handle. */
  539.  
  540.     if(Handle = AllocIFF())
  541.     {
  542.             /* Open the preferences settings file. */
  543.  
  544.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  545.         {
  546.                 /* Make it known as a DOS file handle. */
  547.  
  548.             InitIFFasDOS(Handle);
  549.  
  550.                 /* Open the file for reading. */
  551.  
  552.             if(!(Error = OpenIFF(Handle,IFFF_READ)))
  553.             {
  554.                     /* Stop at the `body' chunk. */
  555.  
  556.                 if(!(Error = StopChunk(Handle,ID_PREF,ID)))
  557.                 {
  558.                         /* Look for it... */
  559.  
  560.                     while(!ParseIFF(Handle,IFFPARSE_SCAN))
  561.                     {
  562.                             /* Read the data. */
  563.  
  564.                         if(ReadChunkBytes(Handle,Data,Size) == Size)
  565.                         {
  566.                             Success = TRUE;
  567.  
  568.                             if(Count)
  569.                             {
  570.                                 Count--;
  571.  
  572.                                 Data = (APTR)((ULONG)Data + Size);
  573.                             }
  574.                             else
  575.                                 break;
  576.                         }
  577.                         else
  578.                         {
  579.                             Error = IoErr();
  580.  
  581.                             Success = FALSE;
  582.  
  583.                             break;
  584.                         }
  585.                     }
  586.                 }
  587.  
  588.                     /* Close the handle. */
  589.  
  590.                 CloseIFF(Handle);
  591.             }
  592.  
  593.                 /* Release the handle. */
  594.  
  595.             Close(Handle -> iff_Stream);
  596.         }
  597.         else
  598.             Error = IoErr();
  599.  
  600.             /* Clean up. */
  601.  
  602.         FreeIFF(Handle);
  603.     }
  604.     else
  605.         Error = ERR_NO_MEM;
  606.  
  607.     if(Error)
  608.         SetIoErr(Error);
  609.  
  610.         /* Return sucess/failure. */
  611.  
  612.     return(Success);
  613. }
  614.  
  615. STATIC VOID
  616. ResetSerialConfig(struct SerialSettings *SerialConfig)
  617. {
  618.     STATIC BYTE                    SerialPrefsRead            = FALSE,
  619.                                 SerialPrefsReadFailed    = FALSE;
  620.     STATIC struct SerialPrefs    SerialPrefs;
  621.  
  622.     memset(SerialConfig,0,sizeof(*SerialConfig));
  623.  
  624.         /* The program will only try to read the preferences
  625.          * settings once; if the first access failed, no
  626.          * other accesses will be made.
  627.          */
  628.  
  629.     if(!SerialPrefsRead && !SerialPrefsReadFailed)
  630.         SerialPrefsReadFailed = ReadSystemPrefs("ENV:sys/serial.prefs",ID_SERL,&SerialPrefs,sizeof(SerialPrefs),1) ^ TRUE;
  631.  
  632.         /* Did we succeed in reading the file? */
  633.  
  634.     if(!SerialPrefsRead)
  635.     {
  636.         SerialConfig -> BaudRate            = 19200;
  637.         SerialConfig -> BitsPerChar            = 8;
  638.         SerialConfig -> Parity                = PARITY_NONE;
  639.         SerialConfig -> StopBits            = 1;
  640.         SerialConfig -> HandshakingProtocol    = HANDSHAKING_RTSCTS_DSR;
  641.         SerialConfig -> SerialBufferSize    = 32768;
  642.     }
  643.     else
  644.     {
  645.             /* Fill in the common data. */
  646.  
  647.         SerialConfig -> BaudRate            = SerialPrefs . sp_BaudRate;
  648.         SerialConfig -> SerialBufferSize    = SerialPrefs . sp_InputBuffer;
  649.         SerialConfig -> BitsPerChar            = SerialPrefs . sp_BitsPerChar;
  650.         SerialConfig -> StopBits            = SerialPrefs . sp_StopBits;
  651.  
  652.             /* Convert the handshaking mode. */
  653.  
  654.         switch(SerialPrefs . sp_InputHandshake)
  655.         {
  656.             case HSHAKE_NONE:
  657.  
  658.                 SerialConfig -> HandshakingProtocol = HANDSHAKING_NONE;
  659.  
  660.                 break;
  661.  
  662.             case HSHAKE_RTS:
  663.  
  664.                 SerialConfig -> HandshakingProtocol = HANDSHAKING_RTSCTS_DSR;
  665.  
  666.                 break;
  667.  
  668.             default:
  669.  
  670.                 SerialConfig -> HandshakingProtocol = HANDSHAKING_NONE;
  671.  
  672.                 break;
  673.         }
  674.  
  675.             /* Convert the parity settings. */
  676.  
  677.         if(SerialPrefs . sp_Parity <= PARITY_SPACE)
  678.             SerialConfig -> Parity = SerialPrefs . sp_Parity;
  679.         else
  680.             SerialConfig -> Parity = PARITY_NONE;
  681.  
  682.         SerialPrefsRead = TRUE;
  683.     }
  684.  
  685.     strcpy(SerialConfig -> SerialDevice,SERIALNAME);
  686.  
  687.     SerialConfig -> Duplex                = DUPLEX_FULL;
  688.     SerialConfig -> HighSpeed            = FALSE;
  689.     SerialConfig -> Shared                = FALSE;
  690.     SerialConfig -> BreakLength            = 250000;
  691.     SerialConfig -> UnitNumber            = 0;
  692.     SerialConfig -> StripBit8            = FALSE;
  693.     SerialConfig -> CheckCarrier        = FALSE;
  694.     SerialConfig -> xONxOFF                = FALSE;
  695.     SerialConfig -> PassThrough            = TRUE;
  696.     SerialConfig -> IgnoreCarrier        = FALSE;
  697.  
  698.     SerialConfig -> Quantum                = 256;
  699.  
  700.     SerialConfig -> UseNet                = FALSE;
  701.     SerialConfig -> NetID                = 0002;
  702.  
  703.     SerialConfig -> SatisfyODURequests    = ODU_RELEASE;
  704.  
  705.     SerialConfig -> LastVersionSaved    = 0;
  706.     SerialConfig -> LastRevisionSaved    = 0;
  707.  
  708.     SerialConfig -> DirectConnection    = FALSE;
  709.  
  710.     SerialConfig -> ReleaseODUWhenOnline    = FALSE;
  711.     SerialConfig -> ReleaseODUWhenDialing    = FALSE;
  712.     SerialConfig -> NoODUIfShared            = FALSE;
  713.     SerialConfig -> Pad                        = 0;
  714. }
  715.  
  716. STATIC VOID
  717. ResetModem(struct ModemSettings *ModemConfig)
  718. {
  719.     memset(ModemConfig,0,sizeof(*ModemConfig));
  720.  
  721.     strcpy(ModemConfig -> ModemInit,    "ATE1V1Q0\\r");
  722.     strcpy(ModemConfig -> ModemExit,    "");
  723.     strcpy(ModemConfig -> ModemHangup,    "~~~~+++~~~~ATH0\\r");
  724.     strcpy(ModemConfig -> DialPrefix,    "ATD\\w");
  725.     strcpy(ModemConfig -> DialSuffix,    "\\r");
  726.  
  727.     strcpy(ModemConfig -> NoCarrier,    "NO CARRIER");
  728.     strcpy(ModemConfig -> NoDialTone,    "NO DIALTONE");
  729.     strcpy(ModemConfig -> Connect,        "CONNECT");
  730.     strcpy(ModemConfig -> Voice,        "VOICE");
  731.     strcpy(ModemConfig -> Ring,            "RING");
  732.     strcpy(ModemConfig -> Busy,            "BUSY");
  733.     strcpy(ModemConfig -> Ok,            "OK");
  734.     strcpy(ModemConfig -> Error,        "ERROR");
  735.  
  736.     ModemConfig -> RedialDelay            = 20;
  737.     ModemConfig -> DialRetries            = 10;
  738.     ModemConfig -> DialTimeout            = 60;
  739.     ModemConfig -> ConnectAutoBaud        = FALSE;
  740.     ModemConfig -> DropDTR                = FALSE;
  741.     ModemConfig -> RedialAfterHangup    = FALSE;
  742.  
  743.     ModemConfig -> NoCarrierIsBusy        = TRUE;
  744.  
  745.     ModemConfig -> ConnectLimit            = 0;
  746.     ModemConfig -> ConnectLimitMacro[0]    = 0;
  747.  
  748.     ModemConfig -> TimeToConnect        = 0;
  749.  
  750.     ModemConfig -> VerboseDialing        = FALSE;
  751.  
  752.     ModemConfig -> DialMode                        = DIALMODE_PULSE;
  753.     ModemConfig -> DoNotSendMainModemCommands    = FALSE;
  754.  
  755.     ModemConfig -> InterDialDelay        = 0;
  756.     ModemConfig -> CharSendDelay        = 0;
  757.  
  758.     strcpy(ModemConfig -> PBX_Prefix,    "0,,,");
  759.  
  760.     ModemConfig -> PBX_Mode                = FALSE;
  761.     ModemConfig -> Pad                    = 0;
  762. }
  763.  
  764. STATIC VOID
  765. ResetScreen(struct ScreenSettings *ScreenConfig)
  766. {
  767.     ULONG             DisplayID;
  768.     struct Screen    *PubScreen;
  769.  
  770.     memset(ScreenConfig,0,sizeof(struct ScreenSettings));
  771.  
  772.     if(!FontPrefsRead && !FontPrefsReadFailed)
  773.         FontPrefsReadFailed = ReadSystemPrefs("ENV:sys/font.prefs",ID_FONT,FontPrefs,sizeof(struct FontPrefs),3) ^ TRUE;
  774. /*
  775.     if(!ScreenModePrefsRead && !ScreenModePrefsReadFailed)
  776.         ScreenModePrefsReadFailed = ReadSystemPrefs("ENV:sys/screenmode.prefs",ID_SCRM,&ScreenModePrefs,sizeof(ScreenModePrefs),1) ^ TRUE;
  777.  
  778.     if(!ScreenModePrefsReadFailed)
  779.     {
  780.         DisplayID = ScreenModePrefs . smp_DisplayID;
  781.  
  782.         if(ModeNotAvailable(DisplayID))
  783.             DisplayID = INVALID_ID;
  784.     }
  785. */
  786.     DisplayID = INVALID_ID;
  787.  
  788.     strcpy(ScreenConfig -> FontName,"topaz.font");
  789.     ScreenConfig -> FontHeight = 8;
  790.  
  791.     if(!FontPrefsReadFailed)
  792.     {
  793.         LONG i;
  794.  
  795.         for(i = 0 ; i < 3 ; i++)
  796.         {
  797.             if(FontPrefs[i] . fp_Type == FP_SCREENFONT)
  798.             {
  799.                 strcpy(ScreenConfig -> FontName,FontPrefs[i] . fp_Name);
  800.                 ScreenConfig -> FontHeight = FontPrefs[i] . fp_TextAttr . ta_YSize;
  801.  
  802.                 break;
  803.             }
  804.         }
  805.     }
  806.  
  807.     if(DisplayID == INVALID_ID)
  808.     {
  809.         if(PubScreen = LockPubScreen(NULL))
  810.         {
  811.             DisplayID = GetVPModeID(&PubScreen -> ViewPort);
  812.  
  813.             UnlockPubScreen(NULL,PubScreen);
  814.         }
  815.         else
  816.             DisplayID = DEFAULT_MONITOR_ID | HIRESLACE_KEY;
  817.     }
  818.  
  819.     ScreenConfig -> DisplayMode            = DisplayID;
  820.     ScreenConfig -> ColourMode            = COLOUR_AMIGA;
  821.     ScreenConfig -> MakeScreenPublic    = TRUE;
  822.     ScreenConfig -> ShanghaiWindows        = FALSE;
  823.     ScreenConfig -> TitleBar            = TRUE;
  824.     ScreenConfig -> StatusLine            = STATUSLINE_STANDARD;
  825.     ScreenConfig -> Blinking            = TRUE;
  826.     ScreenConfig -> FasterLayout        = TRUE;
  827.     ScreenConfig -> UseWorkbench        = FALSE;
  828.  
  829.     ScreenConfig -> PubScreenName[0]    = 0;
  830.     ScreenConfig -> TimeMode            = ONLINETIME_BOTH;
  831.     ScreenConfig -> UsePens                = TRUE;
  832.     ScreenConfig -> PenColourMode        = COLOUR_AMIGA;
  833.  
  834.     ScreenConfig -> DisplayWidth        = 0;
  835.     ScreenConfig -> DisplayHeight        = 0;
  836.     ScreenConfig -> OverscanType        = OSCAN_TEXT;
  837.  
  838.     ScreenConfig -> ShareScreen            = FALSE;
  839.     ScreenConfig -> SplitStatus            = FALSE;
  840.  
  841.     ScreenConfig -> UseColours96        = FALSE;
  842. }
  843.  
  844. STATIC VOID
  845. ResetTerminal(struct TerminalSettings *TerminalConfig)
  846. {
  847.     memset(TerminalConfig,0,sizeof(struct TerminalSettings));
  848.  
  849.     if(!FontPrefsRead && !FontPrefsReadFailed)
  850.         FontPrefsReadFailed = ReadSystemPrefs("ENV:sys/font.prefs",ID_FONT,FontPrefs,sizeof(struct FontPrefs),3) ^ TRUE;
  851.  
  852.     strcpy(TerminalConfig -> TextFontName,"topaz.font");
  853.     TerminalConfig -> TextFontHeight = 8;
  854.  
  855.     strcpy(TerminalConfig -> IBMFontName,"IBM.font");
  856.     TerminalConfig -> IBMFontHeight = 8;
  857.  
  858.     if(!FontPrefsReadFailed)
  859.     {
  860.         LONG i;
  861.  
  862.         for(i = 0 ; i < 3 ; i++)
  863.         {
  864.             if(FontPrefs[i] . fp_Type == FP_SYSFONT)
  865.             {
  866.                 strcpy(TerminalConfig -> TextFontName,FontPrefs[i] . fp_Name);
  867.                 TerminalConfig -> TextFontHeight = FontPrefs[i] . fp_TextAttr . ta_YSize;
  868.  
  869.                 if(TerminalConfig -> TextFontHeight == 8 || TerminalConfig -> TextFontHeight == 11)
  870.                     TerminalConfig -> IBMFontHeight = TerminalConfig -> TextFontHeight;
  871.  
  872.                 break;
  873.             }
  874.         }
  875.     }
  876.  
  877.     TerminalConfig -> BellMode            = BELL_AUDIBLE;
  878.     TerminalConfig -> AlertMode            = ALERT_BEEP_SCREEN;
  879.     TerminalConfig -> EmulationMode        = EMULATION_ANSIVT100;
  880.     TerminalConfig -> FontMode            = FONT_STANDARD;
  881.  
  882.     TerminalConfig -> SendCR            = EOL_CR;
  883.     TerminalConfig -> SendLF            = EOL_LF;
  884.     TerminalConfig -> ReceiveCR            = EOL_CR;
  885.     TerminalConfig -> ReceiveLF            = EOL_LF;
  886.  
  887.     TerminalConfig -> NumColumns        = 0;
  888.     TerminalConfig -> NumLines            = 0;
  889.  
  890.     TerminalConfig -> KeyMapFileName[0]        = 0;
  891.     TerminalConfig -> EmulationFileName[0]    = 0;
  892.     TerminalConfig -> BeepFileName[0]        = 0;
  893.  
  894.     TerminalConfig -> UseTerminalTask = FALSE;
  895.     TerminalConfig -> Pad = 0;
  896. }
  897.  
  898. STATIC VOID
  899. ResetEmulation(struct EmulationSettings *EmulationConfig)
  900. {
  901.     WORD i;
  902.  
  903.     memset(EmulationConfig,0,sizeof(*EmulationConfig));
  904.  
  905.     EmulationConfig -> CursorMode        = KEYMODE_STANDARD;
  906.     EmulationConfig -> NumericMode        = KEYMODE_STANDARD;
  907.  
  908.     EmulationConfig -> NewLineMode        = FALSE;
  909.     EmulationConfig -> InsertMode        = FALSE;
  910.  
  911.     EmulationConfig -> LineWrap            = TRUE;
  912.     EmulationConfig -> CursorWrap        = FALSE;
  913.  
  914.     EmulationConfig -> FontScale        = SCALE_NORMAL;
  915.     EmulationConfig -> ScrollMode        = SCROLL_JUMP;
  916.     EmulationConfig -> DestructiveBackspace    = FALSE;
  917.     EmulationConfig -> SwapBSDelete        = FALSE;
  918.     EmulationConfig -> PrinterEnabled    = TRUE;
  919.     EmulationConfig -> AnswerBack[0]    = 0;
  920.     EmulationConfig -> CLSResetsCursor    = 0;
  921.  
  922.     EmulationConfig -> KeysLocked        = FALSE;
  923.     EmulationConfig -> MaxScroll        = 0;
  924.     EmulationConfig -> MaxJump            = 1;
  925.     EmulationConfig -> CursorLocked        = FALSE;
  926.     EmulationConfig -> FontLocked        = FALSE;
  927.     EmulationConfig -> LockWrapping        = FALSE;
  928.     EmulationConfig -> LockStyle        = FALSE;
  929.     EmulationConfig -> LockColour        = FALSE;
  930.  
  931.     EmulationConfig -> UseStandardPens    = TRUE;
  932.  
  933.     for(i = TEXTATTR_UNDERLINE ; i <= TEXTATTR_INVERSE ; i++)
  934.         EmulationConfig -> Attributes[i] = i;
  935.  
  936.     for(i = 0 ; i < 16 ; i++)
  937.         EmulationConfig -> Pens[i] = i;
  938.  
  939.     EmulationConfig -> TerminalType        = TERMINAL_VT200;
  940. }
  941.  
  942. STATIC VOID
  943. ResetClip(struct ClipSettings *ClipConfig)
  944. {
  945.     memset(ClipConfig,0,sizeof(*ClipConfig));
  946.  
  947.     ClipConfig -> ClipboardUnit    = 0;
  948.     ClipConfig -> LineDelay        = 0;
  949.     ClipConfig -> CharDelay        = 0;
  950.  
  951.     ClipConfig -> InsertPrefix[0] = 0;
  952.     strcpy(ClipConfig -> InsertSuffix,"\\r");
  953.  
  954.     ClipConfig -> LinePrompt[0]    = 0;
  955.     ClipConfig -> SendTimeout    = 0;
  956.     ClipConfig -> PacingMode    = PACE_DIRECT;
  957.     ClipConfig -> ConvertLF        = TRUE;
  958. }
  959.  
  960. STATIC VOID
  961. ResetCapture(struct CaptureSettings *CaptureConfig)
  962. {
  963.     memset(CaptureConfig,0,sizeof(*CaptureConfig));
  964.  
  965.     CaptureConfig -> LogActions            = FALSE;
  966.     CaptureConfig -> LogCall            = FALSE;
  967.     CaptureConfig -> LogFileName[0]        = 0;
  968.  
  969.     CaptureConfig -> MaxBufferSize        = 0;
  970.     CaptureConfig -> BufferEnabled        = TRUE;
  971.  
  972.     CaptureConfig -> ConnectAutoCapture    = FALSE;
  973.     CaptureConfig -> CaptureFilterMode    = FILTER_BOTH;
  974.     CaptureConfig -> CapturePath[0]        = 0;
  975.  
  976.     CaptureConfig -> CallLogFileName[0]    = 0;
  977.     CaptureConfig -> BufferPath[0]        = 0;
  978.  
  979.     CaptureConfig -> AutoCaptureDate    = AUTOCAPTURE_DATE_NAME;
  980.     CaptureConfig -> SearchHistory        = 10;
  981.  
  982.     CaptureConfig -> OpenBufferWindow        = BUFFER_END;
  983.     CaptureConfig -> OpenBufferScreen        = BUFFER_TOP;
  984.     CaptureConfig -> BufferScreenPosition    = SCREEN_CENTRE;
  985.     CaptureConfig -> BufferWidth            = 80;
  986.  
  987.     CaptureConfig -> RememberBufferWindow    = FALSE;
  988.     CaptureConfig -> RememberBufferScreen    = FALSE;
  989.  
  990.     CaptureConfig -> BufferScreenMode        = INVALID_ID;
  991.  
  992.     CaptureConfig -> ConvertChars            = FALSE;
  993.     CaptureConfig -> BufferMode                = BUFFERMODE_FLOW;
  994. }
  995.  
  996. STATIC VOID
  997. ResetTranslationFile(STRPTR Arg,STRPTR PathBuffer)
  998. {
  999.     memset(Arg,0,MAX_FILENAME_LENGTH);
  1000.  
  1001.     if(!PathBuffer)
  1002.         PathBuffer = "TERM:config";
  1003.  
  1004.     if(!LastTranslation[0])
  1005.     {
  1006.         strcpy(LastTranslation,PathBuffer);
  1007.  
  1008.         AddPart(LastTranslation,"translation.prefs",MAX_FILENAME_LENGTH);
  1009.     }
  1010.  
  1011.     strcpy(Arg,LastTranslation);
  1012. }
  1013.  
  1014. STATIC VOID
  1015. ResetMacroFile(STRPTR Arg,STRPTR PathBuffer)
  1016. {
  1017.     memset(Arg,0,MAX_FILENAME_LENGTH);
  1018.  
  1019.     if(!PathBuffer)
  1020.         PathBuffer = "TERM:config";
  1021.  
  1022.     if(!LastMacros[0])
  1023.     {
  1024.         strcpy(LastMacros,PathBuffer);
  1025.  
  1026.         AddPart(LastMacros,"functionkeys.prefs",MAX_FILENAME_LENGTH);
  1027.     }
  1028.  
  1029.     strcpy(Arg,LastMacros);
  1030. }
  1031.  
  1032. STATIC VOID
  1033. ResetCursorFile(STRPTR Arg,STRPTR PathBuffer)
  1034. {
  1035.     memset(Arg,0,MAX_FILENAME_LENGTH);
  1036.  
  1037.     if(!PathBuffer)
  1038.         PathBuffer = "TERM:config";
  1039.  
  1040.     if(!LastCursorKeys[0])
  1041.     {
  1042.         strcpy(LastCursorKeys,PathBuffer);
  1043.  
  1044.         AddPart(LastCursorKeys,"cursorkeys.prefs",MAX_FILENAME_LENGTH);
  1045.     }
  1046.  
  1047.     strcpy(Arg,LastCursorKeys);
  1048. }
  1049.  
  1050. STATIC VOID
  1051. ResetFastMacroFile(STRPTR Arg,STRPTR PathBuffer)
  1052. {
  1053.     memset(Arg,0,MAX_FILENAME_LENGTH);
  1054.  
  1055.     if(!PathBuffer)
  1056.         PathBuffer = "TERM:config";
  1057.  
  1058.     if(!LastFastMacros[0])
  1059.     {
  1060.         strcpy(LastFastMacros,PathBuffer);
  1061.  
  1062.         AddPart(LastFastMacros,"fastmacros.prefs",MAX_FILENAME_LENGTH);
  1063.     }
  1064.  
  1065.     strcpy(Arg,LastFastMacros);
  1066. }
  1067.  
  1068. STATIC VOID
  1069. ResetFile(struct FileSettings *FileConfig,STRPTR PathBuffer)
  1070. {
  1071.     if(FileConfig)
  1072.     {
  1073.         memset(FileConfig,0,sizeof(*FileConfig));
  1074.  
  1075.         if(!PathBuffer)
  1076.             PathBuffer = "TERM:config";
  1077.  
  1078.         strcpy(FileConfig -> ProtocolFileName,"xprzmodem.library");
  1079.  
  1080.         if(!LastTranslation[0])
  1081.         {
  1082.             strcpy(LastTranslation,PathBuffer);
  1083.  
  1084.             AddPart(LastTranslation,"translation.prefs",MAX_FILENAME_LENGTH);
  1085.         }
  1086.  
  1087.         strcpy(FileConfig -> TranslationFileName,LastTranslation);
  1088.  
  1089.         if(!LastMacros[0])
  1090.         {
  1091.             strcpy(LastMacros,PathBuffer);
  1092.  
  1093.             AddPart(LastMacros,"functionkeys.prefs",MAX_FILENAME_LENGTH);
  1094.         }
  1095.  
  1096.         strcpy(FileConfig -> MacroFileName,LastMacros);
  1097.  
  1098.         if(!LastFastMacros[0])
  1099.         {
  1100.             strcpy(LastFastMacros,PathBuffer);
  1101.  
  1102.             AddPart(LastFastMacros,"fastmacros.prefs",MAX_FILENAME_LENGTH);
  1103.         }
  1104.  
  1105.         strcpy(FileConfig -> FastMacroFileName,LastFastMacros);
  1106.  
  1107.         if(!LastCursorKeys[0])
  1108.         {
  1109.             strcpy(LastCursorKeys,PathBuffer);
  1110.  
  1111.             AddPart(LastCursorKeys,"cursorkeys.prefs",MAX_FILENAME_LENGTH);
  1112.         }
  1113.  
  1114.         strcpy(FileConfig -> CursorFileName,LastCursorKeys);
  1115.     }
  1116. }
  1117.  
  1118. STATIC VOID
  1119. ResetPath(struct PathSettings *PathConfig,STRPTR PathBuffer)
  1120. {
  1121.     memset(PathConfig,0,sizeof(*PathConfig));
  1122.  
  1123.     if(!PathBuffer)
  1124.         PathBuffer = "TERM:config";
  1125.  
  1126.     strcpy(PathConfig -> DefaultStorage,PathBuffer);
  1127.  
  1128.     PathConfig -> ASCIIUploadPath[0]    = 0;
  1129.     PathConfig -> ASCIIDownloadPath[0]    = 0;
  1130.     PathConfig -> TextUploadPath[0]        = 0;
  1131.     PathConfig -> TextDownloadPath[0]    = 0;
  1132.     PathConfig -> BinaryUploadPath[0]    = 0;
  1133.     PathConfig -> BinaryDownloadPath[0]    = 0;
  1134.  
  1135.     strcpy(PathConfig -> HelpFile,"PROGDIR:term.guide");
  1136.  
  1137.     strcpy(PathConfig -> DefaultStorage,PathBuffer);
  1138.  
  1139.     GetEnvDOS(PathConfig -> Editor,"EDITOR");
  1140. }
  1141.  
  1142. STATIC VOID
  1143. ResetMisc(struct MiscSettings *MiscConfig)
  1144. {
  1145.     memset(MiscConfig,0,sizeof(*MiscConfig));
  1146.  
  1147.     MiscConfig -> Priority                = 1;
  1148.     MiscConfig -> BackupConfig            = FALSE;
  1149.  
  1150.     MiscConfig -> OpenFastMacroPanel    = FALSE;
  1151.     MiscConfig -> ReleaseDevice            = TRUE;
  1152.  
  1153.     MiscConfig -> TransferServer        = TRUE;
  1154.     MiscConfig -> EmulationServer        = TRUE;
  1155.  
  1156.     MiscConfig -> OverridePath            = TRUE;
  1157.     MiscConfig -> AutoUpload            = TRUE;
  1158.     MiscConfig -> SetArchivedBit        = FALSE;
  1159.     MiscConfig -> IdentifyFiles            = IDENTIFY_FILETYPE;
  1160.     MiscConfig -> TransferIcons            = FALSE;
  1161.     MiscConfig -> CreateIcons            = FALSE;
  1162.     MiscConfig -> SimpleIO                = FALSE;
  1163.     MiscConfig -> PerfMeter                = FALSE;
  1164.  
  1165.     MiscConfig -> IOBufferSize            = 32768;
  1166.     MiscConfig -> HideUploadIcon        = FALSE;
  1167.  
  1168.     MiscConfig -> ProtectiveMode        = TRUE;
  1169.  
  1170.     MiscConfig -> AlertMode                = ALERT_BEEP_SCREEN;
  1171.     MiscConfig -> RequesterMode            = REQUESTERMODE_IGNORE;
  1172.     MiscConfig -> RequesterLeft            = 0;
  1173.     MiscConfig -> RequesterTop            = 0;
  1174.     MiscConfig -> RequesterWidth        = 0;
  1175.     MiscConfig -> RequesterHeight        = 0;
  1176. }
  1177.  
  1178. STATIC VOID
  1179. ResetCommand(struct CommandSettings *CommandConfig)
  1180. {
  1181.     memset(CommandConfig,0,sizeof(*CommandConfig));
  1182. /*
  1183.     CommandConfig -> StartupMacro[0]    = 0;
  1184.     CommandConfig -> LogoffMacro[0]        = 0;
  1185.     CommandConfig -> LoginMacro[0]        = 0;
  1186.     CommandConfig -> UploadMacro[0]        = 0;
  1187.     CommandConfig -> DownloadMacro[0]    = 0;
  1188. */
  1189. }
  1190.  
  1191. STATIC VOID
  1192. ResetTransfer(struct TransferSettings *TransferConfig,STRPTR DefaultLib)
  1193. {
  1194.     WORD i;
  1195.  
  1196.     memset(TransferConfig,0,sizeof(*TransferConfig));
  1197.  
  1198.     if(!DefaultLib)
  1199.         strcpy(TransferConfig -> DefaultLibrary,"xprzmodem.library");
  1200.     else
  1201.         strcpy(TransferConfig -> DefaultLibrary,DefaultLib);
  1202.  
  1203.     for(i = 0 ; i < strlen(TransferConfig -> DefaultLibrary) - 6 ; i++)
  1204.     {
  1205.         if(!Strnicmp(&TransferConfig -> DefaultLibrary[i],"zmodem",6))
  1206.         {
  1207.             strcpy(TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature,"*\030B01");
  1208.  
  1209.             TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Length = strlen(TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature);
  1210.  
  1211.             break;
  1212.         }
  1213.     }
  1214.  
  1215.     strcpy(TransferConfig -> ASCIIUploadLibrary,    "xprascii.library");
  1216.     strcpy(TransferConfig -> ASCIIDownloadLibrary,    "xprascii.library");
  1217.  
  1218.     TransferConfig -> TextUploadLibrary[0]        = 0;
  1219.     TransferConfig -> TextDownloadLibrary[0]    = 0;
  1220.  
  1221.     strcpy(TransferConfig -> BinaryUploadLibrary,"run hydracom device %p speed %b line %c nocarrier rec %> send %m");
  1222.     strcpy(TransferConfig -> BinaryDownloadLibrary,"run hydracom device %p speed %b line %c nocarrier rec %> get");
  1223.  
  1224.     TransferConfig -> InternalASCIIUpload        = FALSE;
  1225.     TransferConfig -> InternalASCIIDownload        = FALSE;
  1226.     TransferConfig -> QuietTransfer                = FALSE;
  1227.     TransferConfig -> MangleFileNames            = FALSE;
  1228.  
  1229.     TransferConfig -> LinePrompt[0]                = 0;
  1230.     TransferConfig -> SendTimeout                = 0;
  1231.     TransferConfig -> PacingMode                = PACE_DIRECT;
  1232.     TransferConfig -> StripBit8                    = FALSE;
  1233.     TransferConfig -> IgnoreDataPastArnold        = TRUE;
  1234.     TransferConfig -> TerminatorChar            = 0x1A;
  1235.     TransferConfig -> SendCR                    = EOL_CR;
  1236.     TransferConfig -> SendLF                    = EOL_LF;
  1237.     TransferConfig -> ReceiveCR                    = EOL_CR;
  1238.     TransferConfig -> ReceiveLF                    = EOL_LF;
  1239.  
  1240.     TransferConfig -> ErrorNotification            = 20;
  1241.     TransferConfig -> TransferNotification        = XFERNOTIFY_ALWAYS;
  1242.  
  1243.     TransferConfig -> DefaultType                = XFER_XPR;
  1244.     TransferConfig -> ASCIIDownloadType            = XFER_XPR;
  1245.     TransferConfig -> ASCIIUploadType            = XFER_XPR;
  1246.     TransferConfig -> TextDownloadType            = XFER_DEFAULT;
  1247.     TransferConfig -> TextUploadType            = XFER_DEFAULT;
  1248.     TransferConfig -> BinaryDownloadType        = XFER_DEFAULT;
  1249.     TransferConfig -> BinaryUploadType            = XFER_DEFAULT;
  1250.  
  1251.     memset(TransferConfig -> Signatures,0,sizeof(TransferConfig -> Signatures));
  1252.  
  1253.     TransferConfig -> OverridePath                = TRUE;
  1254.     TransferConfig -> SetArchivedBit            = FALSE;
  1255.     TransferConfig -> IdentifyFiles                = IDENTIFY_FILETYPE;
  1256.     TransferConfig -> TransferIcons                = FALSE;
  1257.     TransferConfig -> PerfMeter                    = FALSE;
  1258.     TransferConfig -> HideUploadIcon            = FALSE;
  1259. }
  1260.  
  1261.     /* ResetConfig():
  1262.      *
  1263.      *    Initialize configuration with default values.
  1264.      */
  1265.  
  1266. VOID __regargs
  1267. ResetConfig(struct Configuration *Config,STRPTR PathBuffer)
  1268. {
  1269.     if(!PathBuffer)
  1270.         PathBuffer = "TERM:config";
  1271.  
  1272.     ResetPath(Config -> PathConfig,PathBuffer);
  1273.     ResetFile(Config -> FileConfig,PathBuffer);
  1274.  
  1275.     ResetSerialConfig(Config -> SerialConfig);
  1276.     ResetModem(Config -> ModemConfig);
  1277.     ResetScreen(Config -> ScreenConfig);
  1278.     ResetTerminal(Config -> TerminalConfig);
  1279.     ResetEmulation(Config -> EmulationConfig);
  1280.     ResetClip(Config -> ClipConfig);
  1281.     ResetCapture(Config -> CaptureConfig);
  1282.     ResetMisc(Config -> MiscConfig);
  1283.     ResetCommand(Config -> CommandConfig);
  1284.     ResetTransfer(Config -> TransferConfig,Config -> FileConfig ? Config -> FileConfig -> ProtocolFileName : (STRPTR)"xprzmodem.library");
  1285.  
  1286.     ResetTranslationFile(Config -> TranslationFileName,PathBuffer);
  1287.     ResetMacroFile(Config -> MacroFileName,PathBuffer);
  1288.     ResetCursorFile(Config -> CursorFileName,PathBuffer);
  1289.     ResetFastMacroFile(Config -> FastMacroFileName,PathBuffer);
  1290. }
  1291.  
  1292. VOID __regargs
  1293. DeleteConfigEntry(struct Configuration *Config,BYTE Type)
  1294. {
  1295.     if(Type == PREF_ALL)
  1296.     {
  1297.         for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
  1298.             DeleteConfigEntry(Config,Type);
  1299.     }
  1300.     else
  1301.     {
  1302.         switch(Type)
  1303.         {
  1304.             case PREF_SERIAL:
  1305.  
  1306.                 if(Config -> SerialConfig)
  1307.                 {
  1308.                     FreeVecPooled(Config -> SerialConfig);
  1309.  
  1310.                     Config -> SerialConfig = NULL;
  1311.                 }
  1312.  
  1313.                 break;
  1314.  
  1315.             case PREF_MODEM:
  1316.  
  1317.                 if(Config -> ModemConfig)
  1318.                 {
  1319.                     FreeVecPooled(Config -> ModemConfig);
  1320.  
  1321.                     Config -> ModemConfig = NULL;
  1322.                 }
  1323.  
  1324.                 break;
  1325.  
  1326.             case PREF_COMMAND:
  1327.  
  1328.                 if(Config -> CommandConfig)
  1329.                 {
  1330.                     FreeVecPooled(Config -> CommandConfig);
  1331.  
  1332.                     Config -> CommandConfig = NULL;
  1333.                 }
  1334.  
  1335.                 break;
  1336.  
  1337.             case PREF_SCREEN:
  1338.  
  1339.                 if(Config -> ScreenConfig)
  1340.                 {
  1341.                     FreeVecPooled(Config -> ScreenConfig);
  1342.  
  1343.                     Config -> ScreenConfig = NULL;
  1344.                 }
  1345.  
  1346.                 break;
  1347.  
  1348.             case PREF_TERMINAL:
  1349.  
  1350.                 if(Config -> TerminalConfig)
  1351.                 {
  1352.                     FreeVecPooled(Config -> TerminalConfig);
  1353.  
  1354.                     Config -> TerminalConfig = NULL;
  1355.                 }
  1356.  
  1357.                 break;
  1358.  
  1359.             case PREF_PATH:
  1360.  
  1361.                 if(Config -> PathConfig)
  1362.                 {
  1363.                     FreeVecPooled(Config -> PathConfig);
  1364.  
  1365.                     Config -> PathConfig = NULL;
  1366.                 }
  1367.  
  1368.                 break;
  1369.  
  1370.             case PREF_MISC:
  1371.  
  1372.                 if(Config -> MiscConfig)
  1373.                 {
  1374.                     FreeVecPooled(Config -> MiscConfig);
  1375.  
  1376.                     Config -> MiscConfig = NULL;
  1377.                 }
  1378.  
  1379.                 break;
  1380.  
  1381.             case PREF_CLIP:
  1382.  
  1383.                 if(Config -> ClipConfig)
  1384.                 {
  1385.                     FreeVecPooled(Config -> ClipConfig);
  1386.  
  1387.                     Config -> ClipConfig = NULL;
  1388.                 }
  1389.  
  1390.                 break;
  1391.  
  1392.             case PREF_CAPTURE:
  1393.  
  1394.                 if(Config -> CaptureConfig)
  1395.                 {
  1396.                     FreeVecPooled(Config -> CaptureConfig);
  1397.  
  1398.                     Config -> CaptureConfig = NULL;
  1399.                 }
  1400.  
  1401.                 break;
  1402.  
  1403.             case PREF_FILE:
  1404.  
  1405.                 if(Config -> FileConfig)
  1406.                 {
  1407.                     FreeVecPooled(Config -> FileConfig);
  1408.  
  1409.                     Config -> FileConfig = NULL;
  1410.                 }
  1411.  
  1412.                 break;
  1413.  
  1414.             case PREF_EMULATION:
  1415.  
  1416.                 if(Config -> EmulationConfig)
  1417.                 {
  1418.                     FreeVecPooled(Config -> EmulationConfig);
  1419.  
  1420.                     Config -> EmulationConfig = NULL;
  1421.                 }
  1422.  
  1423.                 break;
  1424.  
  1425.             case PREF_TRANSFER:
  1426.  
  1427.                 if(Config -> TransferConfig)
  1428.                 {
  1429.                     FreeVecPooled(Config -> TransferConfig);
  1430.  
  1431.                     Config -> TransferConfig = NULL;
  1432.                 }
  1433.  
  1434.                 break;
  1435.  
  1436.             case PREF_TRANSLATIONFILENAME:
  1437.  
  1438.                 if(Config -> TranslationFileName)
  1439.                 {
  1440.                     FreeVecPooled(Config -> TranslationFileName);
  1441.  
  1442.                     Config -> TranslationFileName = NULL;
  1443.                 }
  1444.  
  1445.                 break;
  1446.  
  1447.             case PREF_MACROFILENAME:
  1448.  
  1449.                 if(Config -> MacroFileName)
  1450.                 {
  1451.                     FreeVecPooled(Config -> MacroFileName);
  1452.  
  1453.                     Config -> MacroFileName = NULL;
  1454.                 }
  1455.  
  1456.                 break;
  1457.  
  1458.             case PREF_CURSORFILENAME:
  1459.  
  1460.                 if(Config -> CursorFileName)
  1461.                 {
  1462.                     FreeVecPooled(Config -> CursorFileName);
  1463.  
  1464.                     Config -> CursorFileName = NULL;
  1465.                 }
  1466.  
  1467.                 break;
  1468.  
  1469.             case PREF_FASTMACROFILENAME:
  1470.  
  1471.                 if(Config -> FastMacroFileName)
  1472.                 {
  1473.                     FreeVecPooled(Config -> FastMacroFileName);
  1474.  
  1475.                     Config -> FastMacroFileName = NULL;
  1476.                 }
  1477.  
  1478.                 break;
  1479.         }
  1480.     }
  1481. }
  1482.  
  1483. VOID __regargs
  1484. ResetConfigEntry(struct Configuration *Configuration,BYTE Type,BYTE Default)
  1485. {
  1486.     if(Type == PREF_ALL)
  1487.     {
  1488.         for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
  1489.             ResetConfigEntry(Configuration,Type,Default);
  1490.     }
  1491.     else
  1492.     {
  1493.         switch(Type)
  1494.         {
  1495.             case PREF_SERIAL:
  1496.  
  1497.                 if(Default || !Config -> SerialConfig)
  1498.                     ResetSerialConfig(Configuration -> SerialConfig);
  1499.                 else
  1500.                     memcpy(Configuration -> SerialConfig,Config -> SerialConfig,sizeof(struct SerialSettings));
  1501.  
  1502.                 break;
  1503.  
  1504.             case PREF_MODEM:
  1505.  
  1506.                 if(Default || !Config -> ModemConfig)
  1507.                     ResetModem(Configuration -> ModemConfig);
  1508.                 else
  1509.                     memcpy(Configuration -> ModemConfig,Config -> ModemConfig,sizeof(struct ModemSettings));
  1510.  
  1511.                 break;
  1512.  
  1513.             case PREF_COMMAND:
  1514.  
  1515.                 if(Default || !Config -> CommandConfig)
  1516.                     ResetCommand(Configuration -> CommandConfig);
  1517.                 else
  1518.                     memcpy(Configuration -> CommandConfig,Config -> CommandConfig,sizeof(struct CommandSettings));
  1519.  
  1520.                 break;
  1521.  
  1522.             case PREF_SCREEN:
  1523.  
  1524.                 if(Default || !Config -> ScreenConfig)
  1525.                     ResetScreen(Configuration -> ScreenConfig);
  1526.                 else
  1527.                     memcpy(Configuration -> ScreenConfig,Config -> ScreenConfig,sizeof(struct ScreenSettings));
  1528.  
  1529.                 FixScreenPens(Configuration -> ScreenConfig);
  1530.  
  1531.                 break;
  1532.  
  1533.             case PREF_TERMINAL:
  1534.  
  1535.                 if(Default || !Config -> TerminalConfig)
  1536.                     ResetTerminal(Configuration -> TerminalConfig);
  1537.                 else
  1538.                     memcpy(Configuration -> TerminalConfig,Config -> TerminalConfig,sizeof(struct TerminalSettings));
  1539.  
  1540.                 break;
  1541.  
  1542.             case PREF_PATH:
  1543.  
  1544.                 if(Default || !Config -> PathConfig)
  1545.                     ResetPath(Configuration -> PathConfig,NULL);
  1546.                 else
  1547.                     memcpy(Configuration -> PathConfig,Config -> PathConfig,sizeof(struct PathSettings));
  1548.  
  1549.                 break;
  1550.  
  1551.             case PREF_MISC:
  1552.  
  1553.                 if(Default || !Config -> MiscConfig)
  1554.                     ResetMisc(Configuration -> MiscConfig);
  1555.                 else
  1556.                     memcpy(Configuration -> MiscConfig,Config -> MiscConfig,sizeof(struct MiscSettings));
  1557.  
  1558.                 break;
  1559.  
  1560.             case PREF_CLIP:
  1561.  
  1562.                 if(Default || !Config -> ClipConfig)
  1563.                     ResetClip(Configuration -> ClipConfig);
  1564.                 else
  1565.                     memcpy(Configuration -> ClipConfig,Config -> ClipConfig,sizeof(struct ClipSettings));
  1566.  
  1567.                 break;
  1568.  
  1569.             case PREF_CAPTURE:
  1570.  
  1571.                 if(Default || !Config -> CaptureConfig)
  1572.                     ResetCapture(Configuration -> CaptureConfig);
  1573.                 else
  1574.                     memcpy(Configuration -> CaptureConfig,Config -> CaptureConfig,sizeof(struct CaptureSettings));
  1575.  
  1576.                 break;
  1577.  
  1578.             case PREF_FILE:
  1579.  
  1580.                 if(Default || !Config -> FileConfig)
  1581.                     ResetFile(Configuration -> FileConfig,NULL);
  1582.                 else
  1583.                 {
  1584.                     if(Configuration -> FileConfig && Config -> FileConfig)
  1585.                         memcpy(Configuration -> FileConfig,Config -> FileConfig,sizeof(struct FileSettings));
  1586.                 }
  1587.  
  1588.                 break;
  1589.  
  1590.             case PREF_EMULATION:
  1591.  
  1592.                 if(Default || !Config -> EmulationConfig)
  1593.                     ResetEmulation(Configuration -> EmulationConfig);
  1594.                 else
  1595.                     memcpy(Configuration -> EmulationConfig,Config -> EmulationConfig,sizeof(struct EmulationSettings));
  1596.  
  1597.                 break;
  1598.  
  1599.             case PREF_TRANSFER:
  1600.  
  1601.                 if(Default || !Config -> TransferConfig)
  1602.                     ResetTransfer(Configuration -> TransferConfig,Config -> FileConfig -> ProtocolFileName);
  1603.                 else
  1604.                     memcpy(Configuration -> TransferConfig,Config -> TransferConfig,sizeof(struct TransferSettings));
  1605.  
  1606.                 break;
  1607.  
  1608.             case PREF_TRANSLATIONFILENAME:
  1609.  
  1610.                 if(Default || !Config -> TranslationFileName)
  1611.                     ResetTranslationFile(Configuration -> TranslationFileName,NULL);
  1612.                 else
  1613.                     strcpy(Configuration -> TranslationFileName,Config -> TranslationFileName);
  1614.  
  1615.                 break;
  1616.  
  1617.             case PREF_MACROFILENAME:
  1618.  
  1619.                 if(Default || !Config -> MacroFileName)
  1620.                     ResetMacroFile(Configuration -> MacroFileName,NULL);
  1621.                 else
  1622.                     strcpy(Configuration -> MacroFileName,Config -> MacroFileName);
  1623.  
  1624.                 break;
  1625.  
  1626.             case PREF_CURSORFILENAME:
  1627.  
  1628.                 if(Default || !Config -> CursorFileName)
  1629.                     ResetMacroFile(Configuration -> CursorFileName,NULL);
  1630.                 else
  1631.                     strcpy(Configuration -> CursorFileName,Config -> CursorFileName);
  1632.  
  1633.                 break;
  1634.  
  1635.             case PREF_FASTMACROFILENAME:
  1636.  
  1637.                 if(Default || !Config -> FastMacroFileName)
  1638.                     ResetMacroFile(Configuration -> FastMacroFileName,NULL);
  1639.                 else
  1640.                     strcpy(Configuration -> FastMacroFileName,Config -> FastMacroFileName);
  1641.  
  1642.                 break;
  1643.         }
  1644.     }
  1645. }
  1646.  
  1647. APTR __regargs
  1648. GetConfigEntry(struct Configuration *Config,BYTE Type)
  1649. {
  1650.     switch(Type)
  1651.     {
  1652.         case PREF_SERIAL:
  1653.  
  1654.             return(Config -> SerialConfig);
  1655.  
  1656.         case PREF_MODEM:
  1657.  
  1658.             return(Config -> ModemConfig);
  1659.  
  1660.         case PREF_COMMAND:
  1661.  
  1662.             return(Config -> CommandConfig);
  1663.  
  1664.         case PREF_SCREEN:
  1665.  
  1666.             return(Config -> ScreenConfig);
  1667.  
  1668.         case PREF_TERMINAL:
  1669.  
  1670.             return(Config -> TerminalConfig);
  1671.  
  1672.         case PREF_PATH:
  1673.  
  1674.             return(Config -> PathConfig);
  1675.  
  1676.         case PREF_MISC:
  1677.  
  1678.             return(Config -> MiscConfig);
  1679.  
  1680.         case PREF_CLIP:
  1681.  
  1682.             return(Config -> ClipConfig);
  1683.  
  1684.         case PREF_CAPTURE:
  1685.  
  1686.             return(Config -> CaptureConfig);
  1687.  
  1688.         case PREF_FILE:
  1689.  
  1690.             return(Config -> FileConfig);
  1691.  
  1692.         case PREF_EMULATION:
  1693.  
  1694.             return(Config -> EmulationConfig);
  1695.  
  1696.         case PREF_TRANSFER:
  1697.  
  1698.             return(Config -> TransferConfig);
  1699.  
  1700.         case PREF_TRANSLATIONFILENAME:
  1701.  
  1702.             return(Config -> TranslationFileName);
  1703.  
  1704.         case PREF_MACROFILENAME:
  1705.  
  1706.             return(Config -> MacroFileName);
  1707.  
  1708.         case PREF_CURSORFILENAME:
  1709.  
  1710.             return(Config -> CursorFileName);
  1711.  
  1712.         case PREF_FASTMACROFILENAME:
  1713.  
  1714.             return(Config -> FastMacroFileName);
  1715.  
  1716.         default:
  1717.  
  1718.             return(NULL);
  1719.     }
  1720. }
  1721.  
  1722. BYTE __regargs
  1723. CreateConfigEntry(struct Configuration *Config,BYTE Type)
  1724. {
  1725.     if(Type == PREF_ALL)
  1726.     {
  1727.         for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
  1728.         {
  1729.             if(!CreateConfigEntry(Config,Type))
  1730.             {
  1731.                 DeleteConfigEntry(Config,PREF_ALL);
  1732.  
  1733.                 return(FALSE);
  1734.             }
  1735.         }
  1736.  
  1737.         return(TRUE);
  1738.     }
  1739.     else
  1740.     {
  1741.         APTR Data;
  1742.  
  1743.         switch(Type)
  1744.         {
  1745.             case PREF_SERIAL:
  1746.  
  1747.                 Data = Config -> SerialConfig;
  1748.                 break;
  1749.  
  1750.             case PREF_MODEM:
  1751.  
  1752.                 Data = Config -> ModemConfig;
  1753.                 break;
  1754.  
  1755.             case PREF_COMMAND:
  1756.  
  1757.                 Data = Config -> CommandConfig;
  1758.                 break;
  1759.  
  1760.             case PREF_SCREEN:
  1761.  
  1762.                 Data = Config -> ScreenConfig;
  1763.                 break;
  1764.  
  1765.             case PREF_TERMINAL:
  1766.  
  1767.                 Data = Config -> TerminalConfig;
  1768.                 break;
  1769.  
  1770.             case PREF_PATH:
  1771.  
  1772.                 Data = Config -> PathConfig;
  1773.                 break;
  1774.  
  1775.             case PREF_MISC:
  1776.  
  1777.                 Data = Config -> MiscConfig;
  1778.                 break;
  1779.  
  1780.             case PREF_CLIP:
  1781.  
  1782.                 Data = Config -> ClipConfig;
  1783.                 break;
  1784.  
  1785.             case PREF_CAPTURE:
  1786.  
  1787.                 Data = Config -> CaptureConfig;
  1788.                 break;
  1789.  
  1790.             case PREF_FILE:
  1791.  
  1792.                 Data = Config -> FileConfig;
  1793.                 break;
  1794.  
  1795.             case PREF_EMULATION:
  1796.  
  1797.                 Data = Config -> EmulationConfig;
  1798.                 break;
  1799.  
  1800.             case PREF_TRANSFER:
  1801.  
  1802.                 Data = Config -> TransferConfig;
  1803.                 break;
  1804.  
  1805.             case PREF_TRANSLATIONFILENAME:
  1806.  
  1807.                 Data = Config -> TranslationFileName;
  1808.                 break;
  1809.  
  1810.             case PREF_MACROFILENAME:
  1811.  
  1812.                 Data = Config -> MacroFileName;
  1813.                 break;
  1814.  
  1815.             case PREF_CURSORFILENAME:
  1816.  
  1817.                 Data = Config -> CursorFileName;
  1818.                 break;
  1819.  
  1820.             case PREF_FASTMACROFILENAME:
  1821.  
  1822.                 Data = Config -> FastMacroFileName;
  1823.                 break;
  1824.  
  1825.             default:
  1826.  
  1827.                 return(FALSE);
  1828.         }
  1829.  
  1830.         if(!Data)
  1831.         {
  1832.             if(Data = AllocVecPooled(SizeTable[Type - 1],MEMF_ANY | MEMF_CLEAR))
  1833.             {
  1834.                 (*ResetTable[Type - 1])(Data,NULL);
  1835.  
  1836.                 switch(Type)
  1837.                 {
  1838.                     case PREF_SERIAL:
  1839.  
  1840.                         Config -> SerialConfig        = Data;
  1841.                         break;
  1842.  
  1843.                     case PREF_MODEM:
  1844.  
  1845.                         Config -> ModemConfig        = Data;
  1846.                         break;
  1847.  
  1848.                     case PREF_COMMAND:
  1849.  
  1850.                         Config -> CommandConfig        = Data;
  1851.                         break;
  1852.  
  1853.                     case PREF_SCREEN:
  1854.  
  1855.                         Config -> ScreenConfig        = Data;
  1856.                         break;
  1857.  
  1858.                     case PREF_TERMINAL:
  1859.  
  1860.                         Config -> TerminalConfig    = Data;
  1861.                         break;
  1862.  
  1863.                     case PREF_PATH:
  1864.  
  1865.                         Config -> PathConfig        = Data;
  1866.                         break;
  1867.  
  1868.                     case PREF_MISC:
  1869.  
  1870.                         Config -> MiscConfig        = Data;
  1871.                         break;
  1872.  
  1873.                     case PREF_CLIP:
  1874.  
  1875.                         Config -> ClipConfig        = Data;
  1876.                         break;
  1877.  
  1878.                     case PREF_CAPTURE:
  1879.  
  1880.                         Config -> CaptureConfig        = Data;
  1881.                         break;
  1882.  
  1883.                     case PREF_FILE:
  1884.  
  1885.                         Config -> FileConfig        = Data;
  1886.                         break;
  1887.  
  1888.                     case PREF_EMULATION:
  1889.  
  1890.                         Config -> EmulationConfig    = Data;
  1891.                         break;
  1892.  
  1893.                     case PREF_TRANSFER:
  1894.  
  1895.                         Config -> TransferConfig    = Data;
  1896.                         break;
  1897.  
  1898.                     case PREF_TRANSLATIONFILENAME:
  1899.  
  1900.                         Config -> TranslationFileName    = Data;
  1901.                         break;
  1902.  
  1903.                     case PREF_MACROFILENAME:
  1904.  
  1905.                         Config -> MacroFileName    = Data;
  1906.                         break;
  1907.  
  1908.                     case PREF_CURSORFILENAME:
  1909.  
  1910.                         Config -> CursorFileName    = Data;
  1911.                         break;
  1912.  
  1913.                     case PREF_FASTMACROFILENAME:
  1914.  
  1915.                         Config -> FastMacroFileName    = Data;
  1916.                         break;
  1917.                 }
  1918.  
  1919.                 return(TRUE);
  1920.             }
  1921.             else
  1922.                 return(FALSE);
  1923.         }
  1924.         else
  1925.             return(TRUE);
  1926.     }
  1927. }
  1928.  
  1929. VOID __regargs
  1930. DeleteConfiguration(struct Configuration *Config)
  1931. {
  1932.     if(Config)
  1933.     {
  1934.         DeleteConfigEntry(Config,PREF_ALL);
  1935.  
  1936.         FreeVecPooled(Config);
  1937.     }
  1938. }
  1939.  
  1940. struct Configuration * __regargs
  1941. CreateConfiguration(BYTE Fill)
  1942. {
  1943.     struct Configuration *Config;
  1944.  
  1945.     if(Config = (struct Configuration *)AllocVecPooled(sizeof(struct Configuration),MEMF_ANY | MEMF_CLEAR))
  1946.     {
  1947.         if(Fill)
  1948.         {
  1949.             if(!CreateConfigEntry(Config,PREF_ALL))
  1950.             {
  1951.                 FreeVecPooled(Config);
  1952.  
  1953.                 return(NULL);
  1954.             }
  1955.         }
  1956.  
  1957.         return(Config);
  1958.     }
  1959.     else
  1960.         return(NULL);
  1961. }
  1962.  
  1963. STATIC BYTE
  1964. WriteConfigChunk(struct IFFHandle *Handle,struct Configuration *Config,BYTE Type,APTR TempBuffer,STRPTR Password)
  1965. {
  1966.     APTR Data;
  1967.  
  1968.     switch(Type)
  1969.     {
  1970.         case PREF_SERIAL:
  1971.  
  1972.             Data = Config -> SerialConfig;
  1973.             break;
  1974.  
  1975.         case PREF_MODEM:
  1976.  
  1977.             Data = Config -> ModemConfig;
  1978.             break;
  1979.  
  1980.         case PREF_COMMAND:
  1981.  
  1982.             Data = Config -> CommandConfig;
  1983.             break;
  1984.  
  1985.         case PREF_SCREEN:
  1986.  
  1987.             Data = Config -> ScreenConfig;
  1988.             break;
  1989.  
  1990.         case PREF_TERMINAL:
  1991.  
  1992.             Data = Config -> TerminalConfig;
  1993.             break;
  1994.  
  1995.         case PREF_PATH:
  1996.  
  1997.             Data = Config -> PathConfig;
  1998.             break;
  1999.  
  2000.         case PREF_MISC:
  2001.  
  2002.             Data = Config -> MiscConfig;
  2003.             break;
  2004.  
  2005.         case PREF_CLIP:
  2006.  
  2007.             Data = Config -> ClipConfig;
  2008.             break;
  2009.  
  2010.         case PREF_CAPTURE:
  2011.  
  2012.             Data = Config -> CaptureConfig;
  2013.             break;
  2014.  
  2015.             // OBSOLETE!
  2016.  
  2017.         case PREF_FILE:
  2018.  
  2019.             return(TRUE);
  2020.  
  2021. //            Data = Config -> FileConfig;
  2022. //            break;
  2023.  
  2024.         case PREF_EMULATION:
  2025.  
  2026.             Data = Config -> EmulationConfig;
  2027.             break;
  2028.  
  2029.         case PREF_TRANSFER:
  2030.  
  2031.             Data = Config -> TransferConfig;
  2032.             break;
  2033.  
  2034.         case PREF_TRANSLATIONFILENAME:
  2035.  
  2036.             Data = Config -> TranslationFileName;
  2037.             break;
  2038.  
  2039.         case PREF_MACROFILENAME:
  2040.  
  2041.             Data = Config -> MacroFileName;
  2042.             break;
  2043.  
  2044.         case PREF_CURSORFILENAME:
  2045.  
  2046.             Data = Config -> CursorFileName;
  2047.             break;
  2048.  
  2049.         case PREF_FASTMACROFILENAME:
  2050.  
  2051.             Data = Config -> FastMacroFileName;
  2052.             break;
  2053.  
  2054.         default:
  2055.  
  2056.             Data = NULL;
  2057.             break;
  2058.     }
  2059.  
  2060.     if(Data)
  2061.     {
  2062.         if(TempBuffer)
  2063.         {
  2064.             Encrypt(Data,SizeTable[Type - 1],TempBuffer,Password,20);
  2065.  
  2066.             Data = TempBuffer;
  2067.         }
  2068.  
  2069.         if(!PushChunk(Handle,0,TypeTable[Type - 1],SizeTable[Type - 1]))
  2070.         {
  2071.             if(WriteChunkRecords(Handle,Data,SizeTable[Type - 1],1) == 1)
  2072.             {
  2073.                 if(!PopChunk(Handle))
  2074.                     return(TRUE);
  2075.             }
  2076.         }
  2077.  
  2078.         return(FALSE);
  2079.     }
  2080.     else
  2081.         return(TRUE);
  2082. }
  2083.  
  2084. STATIC UBYTE
  2085. IsConfigChunk(ULONG ID)
  2086. {
  2087.     UBYTE Type;
  2088.  
  2089.     for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
  2090.     {
  2091.         if(ID == TypeTable[Type - 1])
  2092.             return(Type);
  2093.     }
  2094.  
  2095.     return(0);
  2096. }
  2097.  
  2098. STATIC BYTE
  2099. WriteConfigChunks(struct IFFHandle *Handle,struct Configuration *Config,APTR TempBuffer,STRPTR Password)
  2100. {
  2101.     UBYTE Type;
  2102.  
  2103.     for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
  2104.     {
  2105.         if(!WriteConfigChunk(Handle,Config,Type,TempBuffer,Password))
  2106.             return(FALSE);
  2107.     }
  2108.  
  2109.     return(TRUE);
  2110. }
  2111.  
  2112. VOID __regargs
  2113. SaveConfig(const struct Configuration *Src,struct Configuration *Dst)
  2114. {
  2115.     if(Dst -> SerialConfig && Src -> SerialConfig)
  2116.         memcpy(Dst -> SerialConfig,Src -> SerialConfig,sizeof(struct SerialSettings));
  2117.  
  2118.     if(Dst -> ModemConfig && Src -> ModemConfig)
  2119.         memcpy(Dst -> ModemConfig,Src -> ModemConfig,sizeof(struct ModemSettings));
  2120.  
  2121.     if(Dst -> ScreenConfig && Src -> ScreenConfig)
  2122.     {
  2123.         memcpy(Dst -> ScreenConfig,Src -> ScreenConfig,sizeof(struct ScreenSettings));
  2124.  
  2125.         FixScreenPens(Dst -> ScreenConfig);
  2126.     }
  2127.  
  2128.     if(Dst -> TerminalConfig && Src -> TerminalConfig)
  2129.         memcpy(Dst -> TerminalConfig,Src -> TerminalConfig,sizeof(struct TerminalSettings));
  2130.  
  2131.     if(Dst -> EmulationConfig && Src -> EmulationConfig)
  2132.         memcpy(Dst -> EmulationConfig,Src -> EmulationConfig,sizeof(struct EmulationSettings));
  2133.  
  2134.     if(Dst -> ClipConfig && Src -> ClipConfig)
  2135.         memcpy(Dst -> ClipConfig,Src -> ClipConfig,sizeof(struct ClipSettings));
  2136.  
  2137.     if(Dst -> CaptureConfig && Src -> CaptureConfig)
  2138.         memcpy(Dst -> CaptureConfig,Src -> CaptureConfig,sizeof(struct CaptureSettings));
  2139.  
  2140.     if(Dst -> CommandConfig && Src -> CommandConfig)
  2141.         memcpy(Dst -> CommandConfig,Src -> CommandConfig,sizeof(struct CommandSettings));
  2142.  
  2143.     if(Dst -> MiscConfig && Src -> MiscConfig)
  2144.         memcpy(Dst -> MiscConfig,Src -> MiscConfig,sizeof(struct MiscSettings));
  2145.  
  2146.     if(Dst -> PathConfig && Src -> PathConfig)
  2147.         memcpy(Dst -> PathConfig,Src -> PathConfig,sizeof(struct PathSettings));
  2148.  
  2149.     if(Dst -> FileConfig && Src -> FileConfig)
  2150.         memcpy(Dst -> FileConfig,Src -> FileConfig,sizeof(struct FileSettings));
  2151.  
  2152.     if(Dst -> TransferConfig && Src -> TransferConfig)
  2153.         memcpy(Dst -> TransferConfig,Src -> TransferConfig,sizeof(struct TransferSettings));
  2154.  
  2155.     if(Dst -> TranslationFileName && Src -> TranslationFileName)
  2156.         strcpy(Dst -> TranslationFileName,Src -> TranslationFileName);
  2157.  
  2158.     if(Dst -> MacroFileName && Src -> MacroFileName)
  2159.         strcpy(Dst -> MacroFileName,Src -> MacroFileName);
  2160.  
  2161.     if(Dst -> CursorFileName && Src -> CursorFileName)
  2162.         strcpy(Dst -> CursorFileName,Src -> CursorFileName);
  2163.  
  2164.     if(Dst -> FastMacroFileName && Src -> FastMacroFileName)
  2165.         strcpy(Dst -> FastMacroFileName,Src -> FastMacroFileName);
  2166. }
  2167.  
  2168. VOID __regargs
  2169. UpdateConfig(const struct Configuration *Src,struct Configuration *Dst)
  2170. {
  2171.     if(Src -> SerialConfig)
  2172.         memcpy(Dst -> SerialConfig,Src -> SerialConfig,sizeof(struct SerialSettings));
  2173.  
  2174.     if(Src -> ModemConfig)
  2175.         memcpy(Dst -> ModemConfig,Src -> ModemConfig,sizeof(struct ModemSettings));
  2176.  
  2177.     if(Src -> ScreenConfig)
  2178.     {
  2179.         memcpy(Dst -> ScreenConfig,Src -> ScreenConfig,sizeof(struct ScreenSettings));
  2180.  
  2181.         FixScreenPens(Dst -> ScreenConfig);
  2182.     }
  2183.  
  2184.     if(Src -> TerminalConfig)
  2185.         memcpy(Dst -> TerminalConfig,Src -> TerminalConfig,sizeof(struct TerminalSettings));
  2186.  
  2187.     if(Src -> EmulationConfig)
  2188.         memcpy(Dst -> EmulationConfig,Src -> EmulationConfig,sizeof(struct EmulationSettings));
  2189.  
  2190.     if(Src -> ClipConfig)
  2191.         memcpy(Dst -> ClipConfig,Src -> ClipConfig,sizeof(struct ClipSettings));
  2192.  
  2193.     if(Src -> CaptureConfig)
  2194.         memcpy(Dst -> CaptureConfig,Src -> CaptureConfig,sizeof(struct CaptureSettings));
  2195.  
  2196.     if(Src -> CommandConfig)
  2197.         memcpy(Dst -> CommandConfig,Src -> CommandConfig,sizeof(struct CommandSettings));
  2198.  
  2199.     if(Src -> MiscConfig)
  2200.         memcpy(Dst -> MiscConfig,Src -> MiscConfig,sizeof(struct MiscSettings));
  2201.  
  2202.     if(Src -> PathConfig)
  2203.         memcpy(Dst -> PathConfig,Src -> PathConfig,sizeof(struct PathSettings));
  2204.  
  2205.     if(Src -> FileConfig && Dst -> FileConfig)
  2206.         memcpy(Dst -> FileConfig,Src -> FileConfig,sizeof(struct FileSettings));
  2207.  
  2208.     if(Src -> TransferConfig)
  2209.         memcpy(Dst -> TransferConfig,Src -> TransferConfig,sizeof(struct TransferSettings));
  2210.  
  2211.     if(Src -> TranslationFileName)
  2212.         strcpy(Dst -> TranslationFileName,Src -> TranslationFileName);
  2213.  
  2214.     if(Src -> MacroFileName)
  2215.         strcpy(Dst -> MacroFileName,Src -> MacroFileName);
  2216.  
  2217.     if(Src -> CursorFileName)
  2218.         strcpy(Dst -> CursorFileName,Src -> CursorFileName);
  2219.  
  2220.     if(Src -> FastMacroFileName)
  2221.         strcpy(Dst -> FastMacroFileName,Src -> FastMacroFileName);
  2222. }
  2223.  
  2224. VOID __regargs
  2225. SwapConfig(struct Configuration *Src,struct Configuration *Dst)
  2226. {
  2227.     if(Dst -> SerialConfig && Src -> SerialConfig)
  2228.         swmem(Dst -> SerialConfig,Src -> SerialConfig,sizeof(struct SerialSettings));
  2229.  
  2230.     if(Dst -> ModemConfig && Src -> ModemConfig)
  2231.         swmem(Dst -> ModemConfig,Src -> ModemConfig,sizeof(struct ModemSettings));
  2232.  
  2233.     if(Dst -> ScreenConfig && Src -> ScreenConfig)
  2234.         swmem(Dst -> ScreenConfig,Src -> ScreenConfig,sizeof(struct ScreenSettings));
  2235.  
  2236.     if(Dst -> TerminalConfig && Src -> TerminalConfig)
  2237.         swmem(Dst -> TerminalConfig,Src -> TerminalConfig,sizeof(struct TerminalSettings));
  2238.  
  2239.     if(Dst -> EmulationConfig && Src -> EmulationConfig)
  2240.         swmem(Dst -> EmulationConfig,Src -> EmulationConfig,sizeof(struct EmulationSettings));
  2241.  
  2242.     if(Dst -> ClipConfig && Src -> ClipConfig)
  2243.         swmem(Dst -> ClipConfig,Src -> ClipConfig,sizeof(struct ClipSettings));
  2244.  
  2245.     if(Dst -> CaptureConfig && Src -> CaptureConfig)
  2246.         swmem(Dst -> CaptureConfig,Src -> CaptureConfig,sizeof(struct CaptureSettings));
  2247.  
  2248.     if(Dst -> CommandConfig && Src -> CommandConfig)
  2249.         swmem(Dst -> CommandConfig,Src -> CommandConfig,sizeof(struct CommandSettings));
  2250.  
  2251.     if(Dst -> MiscConfig && Src -> MiscConfig)
  2252.         swmem(Dst -> MiscConfig,Src -> MiscConfig,sizeof(struct MiscSettings));
  2253.  
  2254.     if(Dst -> PathConfig && Src -> PathConfig)
  2255.         swmem(Dst -> PathConfig,Src -> PathConfig,sizeof(struct PathSettings));
  2256.  
  2257.     if(Dst -> TransferConfig && Src -> TransferConfig)
  2258.         swmem(Dst -> TransferConfig,Src -> TransferConfig,sizeof(struct TransferSettings));
  2259.  
  2260.     if(Dst -> FileConfig && Src -> FileConfig)
  2261.         swmem(Dst -> FileConfig,Src -> FileConfig,sizeof(struct FileSettings));
  2262.  
  2263.     if(Dst -> TranslationFileName && Src -> TranslationFileName)
  2264.         swmem(Dst -> TranslationFileName,Src -> TranslationFileName,MAX_FILENAME_LENGTH);
  2265.  
  2266.     if(Dst -> MacroFileName && Src -> MacroFileName)
  2267.         swmem(Dst -> MacroFileName,Src -> MacroFileName,MAX_FILENAME_LENGTH);
  2268.  
  2269.     if(Dst -> CursorFileName && Src -> CursorFileName)
  2270.         swmem(Dst -> CursorFileName,Src -> CursorFileName,MAX_FILENAME_LENGTH);
  2271.  
  2272.     if(Dst -> FastMacroFileName && Src -> FastMacroFileName)
  2273.         swmem(Dst -> FastMacroFileName,Src -> FastMacroFileName,MAX_FILENAME_LENGTH);
  2274. }
  2275.  
  2276.     /* SavePhonebook(STRPTR Name):
  2277.      *
  2278.      *    Save the current phone book to a disk file.
  2279.      */
  2280.  
  2281. BYTE __regargs
  2282. SavePhonebook(STRPTR Name)
  2283. {
  2284.     struct IFFHandle    *Handle;
  2285.     BYTE                 Success = FALSE;
  2286.     LONG                 Error = 0;
  2287.  
  2288.     if(Phonebook && NumPhoneEntries)
  2289.     {
  2290.         if(Handle = (struct IFFHandle *)AllocIFF())
  2291.         {
  2292.             if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  2293.             {
  2294.                 InitIFFasDOS(Handle);
  2295.  
  2296.                 if(!(Error = OpenIFF(Handle,IFFF_WRITE)))
  2297.                 {
  2298.                     if(!(Error = PushChunk(Handle,ID_TERM,ID_CAT,IFFSIZE_UNKNOWN)))
  2299.                     {
  2300.                         if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  2301.                         {
  2302.                             if(!(Error = PushChunk(Handle,0,ID_VERS,IFFSIZE_UNKNOWN)))
  2303.                             {
  2304.                                 struct TermInfo TermInfo;
  2305.  
  2306.                                 TermInfo . Version    = CONFIG_FILE_VERSION;
  2307.                                 TermInfo . Revision    = CONFIG_FILE_REVISION;
  2308.  
  2309.                                 if(WriteChunkRecords(Handle,&TermInfo,sizeof(struct TermInfo),1) == 1)
  2310.                                 {
  2311.                                     if(!(Error = PopChunk(Handle)))
  2312.                                     {
  2313.                                         STRPTR TempBuffer = NULL;
  2314.  
  2315.                                         if(PhonePasswordUsed)
  2316.                                         {
  2317.                                             if(!(Error = PushChunk(Handle,0,ID_PSWD,20)))
  2318.                                             {
  2319.                                                 Success = TRUE;
  2320.  
  2321.                                                 if(WriteChunkBytes(Handle,PhonePassword,20) != 20)
  2322.                                                     Success = FALSE;
  2323.  
  2324.                                                 if(PopChunk(Handle))
  2325.                                                     Success = FALSE;
  2326.  
  2327.                                                 if(Success)
  2328.                                                 {
  2329.                                                     LONG Max = sizeof(struct PhoneHeader),Type;
  2330.  
  2331.                                                     for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
  2332.                                                     {
  2333.                                                         if(SizeTable[Type - 1] > Max)
  2334.                                                             Max = SizeTable[Type - 1];
  2335.                                                     }
  2336.  
  2337.                                                     if(!(TempBuffer = AllocVecPooled(Max,MEMF_ANY)))
  2338.                                                     {
  2339.                                                         Error = ERR_NO_MEM;
  2340.  
  2341.                                                         Success = FALSE;
  2342.                                                     }
  2343.                                                 }
  2344.                                             }
  2345.                                         }
  2346.                                         else
  2347.                                             Success = TRUE;
  2348.  
  2349.                                         if(Success)
  2350.                                         {
  2351.                                             Success = FALSE;
  2352.  
  2353.                                             if(!(Error = PushChunk(Handle,0,ID_DIAL,IFFSIZE_UNKNOWN)))
  2354.                                             {
  2355.                                                 PhonebookGlobals Globals;
  2356.  
  2357.                                                 Globals . Count            = NumPhoneEntries;
  2358.                                                 Globals . ID            = PhonebookID;
  2359.                                                 Globals . DefaultGroup    = PhonebookDefaultGroup;
  2360.                                                 Globals . AutoDial        = PhonebookAutoDial;
  2361.                                                 Globals . AutoExit        = PhonebookAutoExit;
  2362.  
  2363.                                                 if(WriteChunkBytes(Handle,&Globals,sizeof(Globals)) == sizeof(Globals))
  2364.                                                 {
  2365.                                                     if(!(Error = PopChunk(Handle)))
  2366.                                                     {
  2367.                                                         if(!(Error = PopChunk(Handle)))
  2368.                                                         {
  2369.                                                             LONG i;
  2370.  
  2371.                                                             Success = TRUE;
  2372.  
  2373.                                                             for(i = 0 ; Success && i < NumPhoneEntries ; i++)
  2374.                                                             {
  2375.                                                                 Success = FALSE;
  2376.  
  2377.                                                                 if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  2378.                                                                 {
  2379.                                                                     if(!(Error = PushChunk(Handle,0,ID_PHON,sizeof(struct PhoneHeader))))
  2380.                                                                     {
  2381.                                                                         if(TempBuffer)
  2382.                                                                         {
  2383.                                                                             Encrypt((UBYTE *)Phonebook[i] -> Header,sizeof(struct PhoneHeader),TempBuffer,PhonePassword,20);
  2384.  
  2385.                                                                             if(WriteChunkRecords(Handle,TempBuffer,sizeof(struct PhoneHeader),1) == 1)
  2386.                                                                             {
  2387.                                                                                 if(!(Error = PopChunk(Handle)))
  2388.                                                                                 {
  2389.                                                                                     if(WriteConfigChunks(Handle,Phonebook[i] -> Config,TempBuffer,PhonePassword))
  2390.                                                                                     {
  2391.                                                                                         Success = TRUE;
  2392.  
  2393.                                                                                         if(!Phonebook[i] -> Header -> NoRates)
  2394.                                                                                         {
  2395.                                                                                             struct TimeDateNode *TimeDateNode;
  2396.  
  2397.                                                                                             TimeDateNode = (struct TimeDateNode *)Phonebook[i] -> TimeDateList . mlh_Head;
  2398.  
  2399.                                                                                             while(TimeDateNode -> VanillaNode . ln_Succ)
  2400.                                                                                             {
  2401.                                                                                                 if(!(Error = PushChunk(Handle,0,ID_DATE,IFFSIZE_UNKNOWN)))
  2402.                                                                                                 {
  2403.                                                                                                     if(WriteChunkBytes(Handle,&TimeDateNode -> Header,sizeof(struct TimeDateHeader)) != sizeof(struct TimeDateHeader))
  2404.                                                                                                     {
  2405.                                                                                                         Error = IoErr();
  2406.  
  2407.                                                                                                         Success = FALSE;
  2408.  
  2409.                                                                                                         break;
  2410.                                                                                                     }
  2411.                                                                                                     else
  2412.                                                                                                     {
  2413.                                                                                                         if(WriteChunkBytes(Handle,TimeDateNode -> Table,TimeDateNode -> Table[0] . Count * sizeof(struct TimeDate)) != TimeDateNode -> Table[0] . Count * sizeof(struct TimeDate))
  2414.                                                                                                         {
  2415.                                                                                                             Error = IoErr();
  2416.  
  2417.                                                                                                             Success = FALSE;
  2418.  
  2419.                                                                                                             break;
  2420.                                                                                                         }
  2421.                                                                                                     }
  2422.  
  2423.                                                                                                     if(Success)
  2424.                                                                                                     {
  2425.                                                                                                         if(Error = PopChunk(Handle))
  2426.                                                                                                         {
  2427.                                                                                                             Success = FALSE;
  2428.  
  2429.                                                                                                             break;
  2430.                                                                                                         }
  2431.                                                                                                     }
  2432.  
  2433.                                                                                                     TimeDateNode = (struct TimeDateNode *)TimeDateNode -> VanillaNode . ln_Succ;
  2434.                                                                                                 }
  2435.                                                                                             }
  2436.                                                                                         }
  2437.                                                                                     }
  2438.                                                                                     else
  2439.                                                                                     {
  2440.                                                                                         Error = IoErr();
  2441.  
  2442.                                                                                         Success = FALSE;
  2443.                                                                                     }
  2444.                                                                                 }
  2445.                                                                             }
  2446.                                                                             else
  2447.                                                                                 Error = IoErr();
  2448.                                                                         }
  2449.                                                                         else
  2450.                                                                         {
  2451.                                                                             if(WriteChunkRecords(Handle,Phonebook[i] -> Header,sizeof(struct PhoneHeader),1) == 1)
  2452.                                                                             {
  2453.                                                                                 if(!(Error = PopChunk(Handle)))
  2454.                                                                                 {
  2455.                                                                                     if(WriteConfigChunks(Handle,Phonebook[i] -> Config,NULL,NULL))
  2456.                                                                                     {
  2457.                                                                                         Success = TRUE;
  2458.  
  2459.                                                                                         if(!Phonebook[i] -> Header -> NoRates)
  2460.                                                                                         {
  2461.                                                                                             struct TimeDateNode *TimeDateNode;
  2462.  
  2463.                                                                                             TimeDateNode = (struct TimeDateNode *)Phonebook[i] -> TimeDateList . mlh_Head;
  2464.  
  2465.                                                                                             while(TimeDateNode -> VanillaNode . ln_Succ)
  2466.                                                                                             {
  2467.                                                                                                 if(!(Error = PushChunk(Handle,0,ID_DATE,IFFSIZE_UNKNOWN)))
  2468.                                                                                                 {
  2469.                                                                                                     if(WriteChunkBytes(Handle,&TimeDateNode -> Header,sizeof(struct TimeDateHeader)) != sizeof(struct TimeDateHeader))
  2470.                                                                                                     {
  2471.                                                                                                         Error = IoErr();
  2472.  
  2473.                                                                                                         Success = FALSE;
  2474.  
  2475.                                                                                                         break;
  2476.                                                                                                     }
  2477.                                                                                                     else
  2478.                                                                                                     {
  2479.                                                                                                         if(WriteChunkBytes(Handle,TimeDateNode -> Table,TimeDateNode -> Table[0] . Count * sizeof(struct TimeDate)) != TimeDateNode -> Table[0] . Count * sizeof(struct TimeDate))
  2480.                                                                                                         {
  2481.                                                                                                             Error = IoErr();
  2482.  
  2483.                                                                                                             Success = FALSE;
  2484.  
  2485.                                                                                                             break;
  2486.                                                                                                         }
  2487.                                                                                                     }
  2488.  
  2489.                                                                                                     if(Success)
  2490.                                                                                                     {
  2491.                                                                                                         if(Error = PopChunk(Handle))
  2492.                                                                                                         {
  2493.                                                                                                             Success = FALSE;
  2494.  
  2495.                                                                                                             break;
  2496.                                                                                                         }
  2497.                                                                                                     }
  2498.  
  2499.                                                                                                     TimeDateNode = (struct TimeDateNode *)TimeDateNode -> VanillaNode . ln_Succ;
  2500.                                                                                                 }
  2501.                                                                                             }
  2502.                                                                                         }
  2503.                                                                                     }
  2504.                                                                                     else
  2505.                                                                                     {
  2506.                                                                                         Success = FALSE;
  2507.  
  2508.                                                                                         Error = IoErr();
  2509.                                                                                     }
  2510.                                                                                 }
  2511.                                                                             }
  2512.                                                                             else
  2513.                                                                                 Error = IoErr();
  2514.                                                                         }
  2515.                                                                     }
  2516.  
  2517.                                                                     if(Success)
  2518.                                                                     {
  2519.                                                                         if(Error = PopChunk(Handle))
  2520.                                                                             Success = FALSE;
  2521.                                                                     }
  2522.                                                                 }
  2523.                                                             }
  2524.  
  2525.                                                                 // Now for the groups
  2526.  
  2527.                                                             if(Success && PhoneGroupList . mlh_Head -> mln_Succ)
  2528.                                                             {
  2529.                                                                 struct PhoneGroupNode    *GroupNode;
  2530.                                                                 struct PhoneNode        *Node;
  2531.                                                                 PhoneGroupHeader         Header;
  2532.                                                                 BOOL                     GotData = FALSE;
  2533.  
  2534.                                                                     // So the extension stuff is set to zero
  2535.  
  2536.                                                                 memset(&Header,0,sizeof(Header));
  2537.  
  2538.                                                                     // Run down the groups
  2539.  
  2540.                                                                 for(GroupNode = (PhoneGroupNode *)PhoneGroupList . mlh_Head ; Success && GroupNode -> Node . ln_Succ ; GroupNode = (PhoneGroupNode *)GroupNode -> Node . ln_Succ)
  2541.                                                                 {
  2542.                                                                         // Count the members
  2543.  
  2544.                                                                     Header . Count = 0;
  2545.  
  2546.                                                                     for(Node = (struct PhoneNode *)GroupNode -> GroupList . mlh_Head ; Node -> VanillaNode . ln_Succ ; Node = (struct PhoneNode *)Node -> VanillaNode . ln_Succ)
  2547.                                                                         Header . Count++;
  2548.  
  2549.                                                                         // Open the group
  2550.  
  2551.                                                                     if(Header . Count)
  2552.                                                                     {
  2553.                                                                         if(!GotData)
  2554.                                                                         {
  2555.                                                                             if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  2556.                                                                                 GotData = TRUE;
  2557.                                                                         }
  2558.  
  2559.                                                                             // Pick up the group name
  2560.  
  2561.                                                                         strcpy(Header . FullName,GroupNode -> LocalName);
  2562.  
  2563.                                                                         if(!Error)
  2564.                                                                             Error = PushChunk(Handle,0,ID_GRUP,sizeof(Header) + sizeof(LONG) * Header . Count);
  2565.  
  2566.                                                                         if(!Error)
  2567.                                                                         {
  2568.                                                                                 // First the header...
  2569.  
  2570.                                                                             if(WriteChunkBytes(Handle,&Header,sizeof(Header)) == sizeof(Header))
  2571.                                                                             {
  2572.                                                                                     // ...then the IDs of the group members
  2573.  
  2574.                                                                                 for(Node = (struct PhoneNode *)GroupNode -> GroupList . mlh_Head ; Node -> VanillaNode . ln_Succ ; Node = (struct PhoneNode *)Node -> VanillaNode . ln_Succ)
  2575.                                                                                 {
  2576.                                                                                     if(WriteChunkBytes(Handle,&Node -> Entry -> Header -> ID,sizeof(ULONG)) != sizeof(ULONG))
  2577.                                                                                     {
  2578.                                                                                         Success = FALSE;
  2579.                                                                                         break;
  2580.                                                                                     }
  2581.                                                                                 }
  2582.  
  2583.                                                                                 if(!Success)
  2584.                                                                                 {
  2585.                                                                                     Error = IoErr();
  2586.                                                                                     break;
  2587.                                                                                 }
  2588.                                                                             }
  2589.                                                                             else
  2590.                                                                             {
  2591.                                                                                 Error = IoErr();
  2592.                                                                                 Success = FALSE;
  2593.                                                                                 break;
  2594.                                                                             }
  2595.  
  2596.                                                                             if(Error = PopChunk(Handle))
  2597.                                                                                 Success = FALSE;
  2598.                                                                         }
  2599.                                                                         else
  2600.                                                                             Success = FALSE;
  2601.                                                                     }
  2602.                                                                 }
  2603.  
  2604.                                                                 if(Success && GotData)
  2605.                                                                 {
  2606.                                                                     if(Error = PopChunk(Handle))
  2607.                                                                         Success = FALSE;
  2608.                                                                 }
  2609.                                                             }
  2610.                                                         }
  2611.                                                     }
  2612.                                                 }
  2613.                                                 else
  2614.                                                     Error = IoErr();
  2615.                                             }
  2616.                                         }
  2617.  
  2618.                                         if(TempBuffer)
  2619.                                             FreeVecPooled(TempBuffer);
  2620.                                     }
  2621.                                 }
  2622.                                 else
  2623.                                     Error = IoErr();
  2624.                             }
  2625.                         }
  2626.  
  2627.                         if(Success)
  2628.                         {
  2629.                             if(Error = PopChunk(Handle))
  2630.                                 Success = FALSE;
  2631.                         }
  2632.                     }
  2633.  
  2634.                     CloseIFF(Handle);
  2635.                 }
  2636.  
  2637.                 Close(Handle -> iff_Stream);
  2638.             }
  2639.             else
  2640.                 Error = IoErr();
  2641.  
  2642.             FreeIFF(Handle);
  2643.         }
  2644.         else
  2645.             Error = ERR_NO_MEM;
  2646.  
  2647.         if(Success)
  2648.             AddProtection(Name,FIBF_EXECUTE);
  2649.         else
  2650.             DeleteFile(Name);
  2651.     }
  2652.  
  2653.     if(Error)
  2654.         SetIoErr(Error);
  2655.  
  2656.     return(Success);
  2657. }
  2658.  
  2659. STATIC BYTE
  2660. ReadConfigChunk(struct IFFHandle *Handle,struct Configuration *Config,UBYTE Type,LONG Len,STRPTR Password)
  2661. {
  2662.     if(CreateConfigEntry(Config,Type))
  2663.     {
  2664.         APTR Data;
  2665.  
  2666.         switch(Type)
  2667.         {
  2668.             case PREF_SERIAL:
  2669.  
  2670.                 Data = Config -> SerialConfig;
  2671.                 break;
  2672.  
  2673.             case PREF_MODEM:
  2674.  
  2675.                 Data = Config -> ModemConfig;
  2676.                 break;
  2677.  
  2678.             case PREF_COMMAND:
  2679.  
  2680.                 Data = Config -> CommandConfig;
  2681.                 break;
  2682.  
  2683.             case PREF_SCREEN:
  2684.  
  2685.                 Data = Config -> ScreenConfig;
  2686.                 break;
  2687.  
  2688.             case PREF_TERMINAL:
  2689.  
  2690.                 Data = Config -> TerminalConfig;
  2691.                 break;
  2692.  
  2693.             case PREF_PATH:
  2694.  
  2695.                 Data = Config -> PathConfig;
  2696.                 break;
  2697.  
  2698.             case PREF_MISC:
  2699.  
  2700.                 Data = Config -> MiscConfig;
  2701.                 break;
  2702.  
  2703.             case PREF_CLIP:
  2704.  
  2705.                 Data = Config -> ClipConfig;
  2706.                 break;
  2707.  
  2708.             case PREF_CAPTURE:
  2709.  
  2710.                 Data = Config -> CaptureConfig;
  2711.                 break;
  2712.  
  2713.             case PREF_FILE:
  2714.  
  2715.                 Data = Config -> FileConfig;
  2716.                 break;
  2717.  
  2718.             case PREF_EMULATION:
  2719.  
  2720.                 Data = Config -> EmulationConfig;
  2721.                 break;
  2722.  
  2723.             case PREF_TRANSFER:
  2724.  
  2725.                 Data = Config -> TransferConfig;
  2726.                 break;
  2727.  
  2728.             case PREF_TRANSLATIONFILENAME:
  2729.  
  2730.                 Data = Config -> TranslationFileName;
  2731.                 break;
  2732.  
  2733.             case PREF_MACROFILENAME:
  2734.  
  2735.                 Data = Config -> MacroFileName;
  2736.                 break;
  2737.  
  2738.             case PREF_CURSORFILENAME:
  2739.  
  2740.                 Data = Config -> CursorFileName;
  2741.                 break;
  2742.  
  2743.             case PREF_FASTMACROFILENAME:
  2744.  
  2745.                 Data = Config -> FastMacroFileName;
  2746.                 break;
  2747.         }
  2748.  
  2749.         Len = MIN(SizeTable[Type - 1],Len);
  2750.  
  2751.         if(ReadChunkBytes(Handle,Data,Len) == Len)
  2752.         {
  2753.             if(Password)
  2754.                 Decrypt(Data,Len,Data,Password,20);
  2755.  
  2756.             if(Type == PREF_SCREEN)
  2757.                 FixScreenPens(Data);
  2758.  
  2759.             return(TRUE);
  2760.         }
  2761.     }
  2762.  
  2763.     return(FALSE);
  2764. }
  2765.  
  2766.     /* LoadPhonebook(STRPTR Name):
  2767.      *
  2768.      *    Restore a phone book from a disk file.
  2769.      */
  2770.  
  2771. BYTE __regargs
  2772. LoadPhonebook(STRPTR Name,PhonebookHandle *BookHandle)
  2773. {
  2774.     struct PhoneEntry    **PrivatePhonebook;
  2775.     LONG                 PrivatePhoneSize    = 0,
  2776.                          CurrentPhoneSize    = 0,
  2777.                          Count                = 0,
  2778.                          Index                = 0;
  2779.     BYTE                 Success            = FALSE,
  2780.                          LastHadTime        = TRUE,
  2781.                          UsePhonePassword    = FALSE,
  2782.                          FirstChunk            = TRUE,
  2783.                          UseOld                = FALSE;
  2784.     struct IFFHandle    *Handle;
  2785.     struct ContextNode    *Chunk;
  2786.     struct TimeDateNode    *TimeDateNode;
  2787.     UBYTE                 ConfigChunkType,
  2788.                          PasswordBuffer[20];
  2789.     BYTE                 CheckedChunk = FALSE;
  2790.     LONG                 Error = 0;
  2791.     PhonebookGlobals     Globals;
  2792.     struct timeval         Now;
  2793.     ULONG                 PrivatePhonebookID;
  2794.     struct MinList         LocalPhoneGroupList;
  2795.     BOOL                 GotID = FALSE;
  2796.  
  2797.     NewList((struct List *)&LocalPhoneGroupList);
  2798.  
  2799.     GetSysTime(&Now);
  2800.  
  2801.     memset(&Globals,0,sizeof(Globals));
  2802.  
  2803.     Globals . ID            = Now . tv_secs;
  2804.     Globals . DefaultGroup    = 0;
  2805.     Globals . AutoDial        = 0;
  2806.     Globals . AutoExit        = 0;
  2807.  
  2808.     if(Handle = AllocIFF())
  2809.     {
  2810.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  2811.         {
  2812.             InitIFFasDOS(Handle);
  2813.  
  2814.             if(!(Error = OpenIFF(Handle,IFFF_READ)))
  2815.             {
  2816.                 if(!(Error = StopChunks(Handle,Stops,NUM_STOPS)))
  2817.                 {
  2818.                     struct TermInfo TermInfo;
  2819.  
  2820.                     while(!ParseIFF(Handle,IFFPARSE_SCAN))
  2821.                     {
  2822.                         Chunk = CurrentChunk(Handle);
  2823.  
  2824.                             /* Is this the first chunk to be read? */
  2825.  
  2826.                         if(!CheckedChunk)
  2827.                         {
  2828.                                 /* The first chunk must be a
  2829.                                  * catalog chunk, or this is
  2830.                                  * not a proper phonebook file.
  2831.                                  */
  2832.  
  2833.                             if(Chunk -> cn_ID != ID_CAT)
  2834.                                 break;
  2835.                             else
  2836.                                 CheckedChunk = TRUE;
  2837.                         }
  2838.  
  2839.                         if(Chunk -> cn_ID == ID_VERS)
  2840.                         {
  2841.                             if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  2842.                             {
  2843.                                 if(TermInfo . Version != CONFIG_FILE_VERSION || (TermInfo . Version == CONFIG_FILE_VERSION && TermInfo . Revision > CONFIG_FILE_REVISION))
  2844.                                 {
  2845.                                     if(TermInfo . Version == 2 && TermInfo . Revision == 4)
  2846.                                         UseOld = TRUE;
  2847.  
  2848.                                     if(TermInfo . Version != 3)
  2849.                                         break;
  2850.                                 }
  2851.                             }
  2852.                             else
  2853.                             {
  2854.                                 Error = IoErr();
  2855.  
  2856.                                 break;
  2857.                             }
  2858.                         }
  2859.  
  2860.                         if(Chunk -> cn_ID == ID_PSWD)
  2861.                         {
  2862.                             if(ReadChunkBytes(Handle,PasswordBuffer,20) == 20)
  2863.                             {
  2864.                                 if(BookHandle)
  2865.                                 {
  2866.                                     if(BookHandle -> PhonePasswordUsed)
  2867.                                     {
  2868.                                         if(!memcmp(BookHandle -> PhonePassword,PasswordBuffer,20))
  2869.                                         {
  2870.                                             UsePhonePassword = TRUE;
  2871.  
  2872.                                             continue;
  2873.                                         }
  2874.                                     }
  2875.                                 }
  2876.                                 else
  2877.                                 {
  2878.                                     if(PhonePasswordUsed)
  2879.                                     {
  2880.                                         if(!memcmp(PhonePassword,PasswordBuffer,20))
  2881.                                         {
  2882.                                             UsePhonePassword = TRUE;
  2883.  
  2884.                                             continue;
  2885.                                         }
  2886.                                     }
  2887.                                 }
  2888.  
  2889.                                 memset(SharedBuffer,0,21);
  2890.  
  2891.                                 if(GetString(FALSE,TRUE,21,LocaleString(MSG_PHONEPANEL_PLEASE_ENTER_PASSWORD_TXT),SharedBuffer))
  2892.                                 {
  2893.                                     UBYTE AnotherBuffer[20];
  2894.  
  2895.                                     Encrypt(SharedBuffer,20,AnotherBuffer,SharedBuffer,strlen(SharedBuffer));
  2896.  
  2897.                                     if(!memcmp(PasswordBuffer,AnotherBuffer,20))
  2898.                                     {
  2899.                                         UsePhonePassword = TRUE;
  2900.  
  2901.                                         continue;
  2902.                                     }
  2903.                                     else
  2904.                                     {
  2905.                                         MyEasyRequest(Window,LocaleString(MSG_TERMPHONE_WRONG_PASSWORD_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),Name);
  2906.  
  2907.                                         break;
  2908.                                     }
  2909.                                 }
  2910.                                 else
  2911.                                     break;
  2912.                             }
  2913.                             else
  2914.                             {
  2915.                                 Error = IoErr();
  2916.  
  2917.                                 break;
  2918.                             }
  2919.                         }
  2920.  
  2921.                         if(Chunk -> cn_ID == ID_DIAL)
  2922.                         {
  2923.                             WORD Size = MIN(sizeof(PhonebookGlobals),Chunk -> cn_Size);
  2924.  
  2925.                             if(ReadChunkBytes(Handle,&Globals,Size) == Size)
  2926.                             {
  2927.                                 CurrentPhoneSize = Globals . Count;
  2928.  
  2929.                                 if(Size >= sizeof(PhonebookGlobals))
  2930.                                     GotID = TRUE;
  2931.  
  2932.                                 PrivatePhonebookID = Globals . ID;
  2933.  
  2934.                                 if(!CurrentPhoneSize)
  2935.                                     break;
  2936.                                 else
  2937.                                 {
  2938.                                     if(!(PrivatePhonebook = CreatePhonebook(CurrentPhoneSize,&PrivatePhoneSize,TRUE)))
  2939.                                     {
  2940.                                         Error = ERR_NO_MEM;
  2941.  
  2942.                                         break;
  2943.                                     }
  2944.                                 }
  2945.                             }
  2946.                             else
  2947.                             {
  2948.                                 Error = IoErr();
  2949.  
  2950.                                 break;
  2951.                             }
  2952.                         }
  2953.  
  2954.                         if(Chunk -> cn_ID == ID_PHON)
  2955.                         {
  2956.                             WORD Size = MIN(sizeof(struct PhoneHeader),Chunk -> cn_Size);
  2957.  
  2958.                             if(!CurrentPhoneSize)
  2959.                                 break;
  2960.  
  2961.                             if(!LastHadTime)
  2962.                             {
  2963.                                 if(TimeDateNode = CreateTimeDateNode(-1,-1,"",2))
  2964.                                     AddTail((struct List *)&PrivatePhonebook[Index] -> TimeDateList,&TimeDateNode -> VanillaNode);
  2965.                             }
  2966.  
  2967.                             if(!FirstChunk)
  2968.                                 Index++;
  2969.                             else
  2970.                                 FirstChunk = FALSE;
  2971.  
  2972.                             memset(PrivatePhonebook[Index] -> Header,0,sizeof(struct PhoneHeader));
  2973.  
  2974.                             if(ReadChunkBytes(Handle,PrivatePhonebook[Index] -> Header,Size) == Size)
  2975.                             {
  2976.                                 if(UsePhonePassword)
  2977.                                     Decrypt((UBYTE *)PrivatePhonebook[Index] -> Header,Size,(UBYTE *)PrivatePhonebook[Index] -> Header,PasswordBuffer,20);
  2978.  
  2979.                                 PrivatePhonebook[Index] -> Count = -1;
  2980.  
  2981.                                 if(!GotID)
  2982.                                     PrivatePhonebook[Index] -> Header -> ID = PrivatePhonebookID++;
  2983.  
  2984.                                 LastHadTime = FALSE;
  2985.  
  2986.                                 Count++;
  2987.                             }
  2988.                             else
  2989.                             {
  2990.                                 Error = IoErr();
  2991.  
  2992.                                 break;
  2993.                             }
  2994.                         }
  2995.  
  2996.                             // Mucho importante -- must follow the phonebook entries
  2997.  
  2998.                         if(Chunk -> cn_ID == ID_GRUP)
  2999.                         {
  3000.                             PhoneGroupHeader     Header;
  3001.                             struct MinList        *GroupList;
  3002.  
  3003.                             DB(kprintf("--> ID_GRUP\n"));
  3004.  
  3005.                             if(BookHandle)
  3006.                                 GroupList = BookHandle -> PhoneGroupList;
  3007.                             else
  3008.                                 GroupList = &LocalPhoneGroupList;
  3009.  
  3010.                             if(GroupList)
  3011.                             {
  3012.                                 if(ReadChunkBytes(Handle,&Header,sizeof(Header)) == sizeof(Header))
  3013.                                 {
  3014.                                     PhoneGroupNode    *GroupNode;
  3015.                                     ULONG             ID;
  3016.                                     LONG             i;
  3017.  
  3018.                                     GroupNode = NULL;
  3019.  
  3020.                                     Success = TRUE;
  3021.  
  3022.                                     DB(kprintf("group name |%s| entries %ld\n",Header . FullName,Header . Count));
  3023.  
  3024.                                     for(i = 0 ; Success && i < Header . Count ; i++)
  3025.                                     {
  3026.                                         if(ReadChunkBytes(Handle,&ID,sizeof(ULONG)) == sizeof(ULONG))
  3027.                                         {
  3028.                                             struct PhoneNode    *Node;
  3029.                                             LONG                 j;
  3030.  
  3031.                                             DB(kprintf("looking for 0x%08lx\n",ID));
  3032.  
  3033.                                             for(j = 0 ; j < CurrentPhoneSize ; j++)
  3034.                                             {
  3035.                                                 if(PrivatePhonebook[j] -> Header -> ID == ID)
  3036.                                                 {
  3037.                                                     DB(kprintf("found it |%s|\n",PrivatePhonebook[j] -> Header -> Name));
  3038.  
  3039.                                                     if(!GroupNode)
  3040.                                                     {
  3041.                                                         if(!(GroupNode = (PhoneGroupNode *)AllocVecPooled(sizeof(PhoneGroupNode),MEMF_ANY | MEMF_CLEAR)))
  3042.                                                         {
  3043.                                                             Error = ERROR_NO_FREE_STORE;
  3044.  
  3045.                                                             Success = FALSE;
  3046.  
  3047.                                                             break;
  3048.                                                         }
  3049.  
  3050.                                                         strcpy(GroupNode -> LocalName,Header . FullName);
  3051.  
  3052.                                                         GroupNode -> Node . ln_Name = GroupNode -> LocalName;
  3053.  
  3054.                                                         NewList((struct List *)&GroupNode -> GroupList);
  3055.  
  3056.                                                         AddTail((struct List *)&LocalPhoneGroupList,(struct Node *)GroupNode);
  3057.                                                     }
  3058.  
  3059.                                                     if(Node = (struct PhoneNode *)AllocVecPooled(sizeof(struct PhoneNode),MEMF_ANY | MEMF_CLEAR))
  3060.                                                     {
  3061.                                                         PrivatePhonebook[j] -> ThisGroup    = GroupNode;
  3062.                                                         PrivatePhonebook[j] -> NodeGroup    = Node;
  3063.  
  3064.                                                         Node -> VanillaNode . ln_Name    = Node -> LocalName;
  3065.                                                         Node -> Entry                    = PrivatePhonebook[j];
  3066.  
  3067.                                                         SPrintf(Node -> LocalName,"      %s",PrivatePhonebook[j] -> Header -> Name);
  3068.  
  3069.                                                         AddTail((struct List *)&GroupNode -> GroupList,(struct Node *)Node);
  3070.                                                     }
  3071.                                                     else
  3072.                                                     {
  3073.                                                         Error = ERROR_NO_FREE_STORE;
  3074.  
  3075.                                                         Success = FALSE;
  3076.  
  3077.                                                         break;
  3078.                                                     }
  3079.                                                 }
  3080.                                             }
  3081.                                         }
  3082.                                         else
  3083.                                         {
  3084.                                             Error = IoErr();
  3085.  
  3086.                                             Success = FALSE;
  3087.  
  3088.                                             break;
  3089.                                         }
  3090.                                     }
  3091.                                 }
  3092.                                 else
  3093.                                 {
  3094.                                     Error = IoErr();
  3095.  
  3096.                                     Success = FALSE;
  3097.                                 }
  3098.                             }
  3099.  
  3100.                             if(!Success)
  3101.                                 break;
  3102.                         }
  3103.  
  3104.                         if(ConfigChunkType = IsConfigChunk(Chunk -> cn_ID))
  3105.                         {
  3106.                             if(!CurrentPhoneSize)
  3107.                                 break;
  3108.  
  3109.                             if(UsePhonePassword)
  3110.                             {
  3111.                                 if(!ReadConfigChunk(Handle,PrivatePhonebook[Index] -> Config,ConfigChunkType,Chunk -> cn_Size,PasswordBuffer))
  3112.                                 {
  3113.                                     if(Count)
  3114.                                         CurrentPhoneSize = Count - 1;
  3115.                                     else
  3116.                                         CurrentPhoneSize = 0;
  3117.  
  3118.                                     break;
  3119.                                 }
  3120.                                 else
  3121.                                     FixOldConfig(PrivatePhonebook[Index] -> Config,ConfigChunkType,TRUE,TermInfo . Version,TermInfo . Revision);
  3122.                             }
  3123.                             else
  3124.                             {
  3125.                                 if(!ReadConfigChunk(Handle,PrivatePhonebook[Index] -> Config,ConfigChunkType,Chunk -> cn_Size,NULL))
  3126.                                 {
  3127.                                     if(Count)
  3128.                                         CurrentPhoneSize = Count - 1;
  3129.                                     else
  3130.                                         CurrentPhoneSize = 0;
  3131.  
  3132.                                     break;
  3133.                                 }
  3134.                                 else
  3135.                                     FixOldConfig(PrivatePhonebook[Index] -> Config,ConfigChunkType,TRUE,TermInfo . Version,TermInfo . Revision);
  3136.                             }
  3137.                         }
  3138.  
  3139.                             // Special treatment for obsolete "FILE" chunk
  3140.  
  3141.                         if(Chunk -> cn_ID == ID_FILE)
  3142.                         {
  3143.                             struct Configuration *Config = PrivatePhonebook[Index] -> Config;
  3144.                             LONG i;
  3145.  
  3146.                             for(i = PREF_TRANSLATIONFILENAME ; i <= PREF_FASTMACROFILENAME ; i++)
  3147.                             {
  3148.                                 if(!CreateConfigEntry(Config,i))
  3149.                                 {
  3150.                                     Error = ERROR_NO_FREE_STORE;
  3151.                                     break;
  3152.                                 }
  3153.                             }
  3154.  
  3155.                             if(!Error)
  3156.                             {
  3157.                                 strcpy(Config -> TranslationFileName,    Config -> FileConfig -> TranslationFileName);
  3158.                                 strcpy(Config -> MacroFileName,            Config -> FileConfig -> MacroFileName);
  3159.                                 strcpy(Config -> CursorFileName,        Config -> FileConfig -> CursorFileName);
  3160.                                 strcpy(Config -> FastMacroFileName,        Config -> FileConfig -> FastMacroFileName);
  3161.  
  3162.                                 DeleteConfigEntry(Config,PREF_FILE);
  3163.                             }
  3164.                         }
  3165.  
  3166.                         if(Chunk -> cn_ID == ID_DATE)
  3167.                         {
  3168.                             if(!PrivatePhonebook[Index] -> Header -> NoRates)
  3169.                             {
  3170.                                 WORD Count = (Chunk -> cn_Size - sizeof(struct TimeDateHeader)) / sizeof(struct TimeDate);
  3171.  
  3172.                                 if(!CurrentPhoneSize)
  3173.                                     break;
  3174.  
  3175.                                 if(TimeDateNode = CreateTimeDateNode(-1,-1,"",Count))
  3176.                                 {
  3177.                                     if(ReadChunkBytes(Handle,&TimeDateNode -> Header,sizeof(struct TimeDateHeader)) == sizeof(struct TimeDateHeader))
  3178.                                     {
  3179.                                         if(ReadChunkRecords(Handle,TimeDateNode -> Table,sizeof(struct TimeDate),Count) == Count)
  3180.                                         {
  3181.                                             AdaptTimeDateNode(TimeDateNode);
  3182.  
  3183.                                             AddTail((struct List *)&PrivatePhonebook[Index] -> TimeDateList,&TimeDateNode -> VanillaNode);
  3184.  
  3185.                                             LastHadTime = TRUE;
  3186.                                         }
  3187.                                         else
  3188.                                         {
  3189.                                             Error = IoErr();
  3190.  
  3191.                                             FreeTimeDateNode(TimeDateNode);
  3192.                                         }
  3193.                                     }
  3194.                                     else
  3195.                                     {
  3196.                                         Error = IoErr();
  3197.  
  3198.                                         FreeTimeDateNode(TimeDateNode);
  3199.                                     }
  3200.                                 }
  3201.                             }
  3202.                         }
  3203.                     }
  3204.  
  3205.                     if(CurrentPhoneSize && !Error)
  3206.                     {
  3207.                         LONG i;
  3208.  
  3209.                         if(!LastHadTime)
  3210.                         {
  3211.                             if(TimeDateNode = CreateTimeDateNode(-1,-1,"",2))
  3212.                                 AddTail((struct List *)&PrivatePhonebook[Index] -> TimeDateList,&TimeDateNode -> VanillaNode);
  3213.                         }
  3214.  
  3215.                         DB(for(i = 0 ; i < CurrentPhoneSize ; i++))
  3216.                             DB(kprintf("0x%08lx |%s|\n",PrivatePhonebook[i] -> Header -> ID,PrivatePhonebook[i] -> Header -> Name));
  3217.  
  3218.                         if(BookHandle)
  3219.                         {
  3220.                             BookHandle -> PhonebookID = PrivatePhonebookID;
  3221.  
  3222.                             if(BookHandle -> Phonebook)
  3223.                                 DeletePhonebook(BookHandle -> Phonebook,BookHandle -> PhoneSize,TRUE);
  3224.  
  3225.                             BookHandle -> Phonebook            = PrivatePhonebook;
  3226.                             BookHandle -> PhoneSize            = PrivatePhoneSize;
  3227.                             BookHandle -> NumPhoneEntries    = CurrentPhoneSize;
  3228.                             BookHandle -> DefaultGroup        = Globals . DefaultGroup;
  3229.                             BookHandle -> AutoDial            = Globals . AutoDial;
  3230.                             BookHandle -> AutoExit            = Globals . AutoExit;
  3231.  
  3232.                             if(BookHandle -> PhoneGroupList)
  3233.                             {
  3234.                                 DeletePhoneGroupList(BookHandle -> PhoneGroupList);
  3235.  
  3236.                                 MoveList((struct List *)&LocalPhoneGroupList,(struct List *)BookHandle -> PhoneGroupList);
  3237.                             }
  3238.                             else
  3239.                                 DeletePhoneGroupList(&LocalPhoneGroupList);
  3240.  
  3241.                             memcpy(BookHandle -> PhonePassword,PasswordBuffer,20);
  3242.                             BookHandle -> PhonePasswordUsed = UsePhonePassword;
  3243.  
  3244.                             for(i = BookHandle -> NumPhoneEntries ; i < BookHandle -> PhoneSize ; i++)
  3245.                             {
  3246.                                 if(BookHandle -> Phonebook[i])
  3247.                                 {
  3248.                                     if(BookHandle -> Phonebook[i] -> Config)
  3249.                                         DeleteConfiguration(BookHandle -> Phonebook[i] -> Config);
  3250.  
  3251.                                     FreeVecPooled(BookHandle -> Phonebook[i]);
  3252.  
  3253.                                     BookHandle -> Phonebook[i] = NULL;
  3254.                                 }
  3255.                             }
  3256.  
  3257.                             for(i = 0 ; i < BookHandle -> NumPhoneEntries ; i++)
  3258.                                 FinalFix(BookHandle -> Phonebook[i] -> Config,TRUE,TermInfo . Version,TermInfo . Revision);
  3259.                         }
  3260.                         else
  3261.                         {
  3262.                             PhonebookID = PrivatePhonebookID;
  3263.  
  3264.                             if(Phonebook)
  3265.                                 DeletePhonebook(Phonebook,PhoneSize,TRUE);
  3266.  
  3267.                             Phonebook                = PrivatePhonebook;
  3268.                             PhoneSize                = PrivatePhoneSize;
  3269.                             NumPhoneEntries            = CurrentPhoneSize;
  3270.                             PhonebookDefaultGroup    = Globals . DefaultGroup;
  3271.                             PhonebookAutoDial        = Globals . AutoDial;
  3272.                             PhonebookAutoExit        = Globals . AutoExit;
  3273.  
  3274.                             DeletePhoneGroupList(&PhoneGroupList);
  3275.  
  3276.                             MoveList((struct List *)&LocalPhoneGroupList,(struct List *)&PhoneGroupList);
  3277.  
  3278.                             memcpy(PhonePassword,PasswordBuffer,20);
  3279.                             PhonePasswordUsed = UsePhonePassword;
  3280.  
  3281.                             for(i = NumPhoneEntries ; i < PhoneSize ; i++)
  3282.                             {
  3283.                                 if(Phonebook[i])
  3284.                                 {
  3285.                                     if(Phonebook[i] -> Config)
  3286.                                         DeleteConfiguration(Phonebook[i] -> Config);
  3287.  
  3288.                                     FreeVecPooled(Phonebook[i]);
  3289.  
  3290.                                     Phonebook[i] = NULL;
  3291.                                 }
  3292.                             }
  3293.  
  3294.                             for(i = 0 ; i < NumPhoneEntries ; i++)
  3295.                                 FinalFix(Phonebook[i] -> Config,TRUE,TermInfo . Version,TermInfo . Revision);
  3296.                         }
  3297.  
  3298.                         FreeDialList(TRUE);
  3299.  
  3300.                         Success = TRUE;
  3301.                     }
  3302.                     else
  3303.                     {
  3304.                         DeletePhoneGroupList(&LocalPhoneGroupList);
  3305.  
  3306.                         if(PrivatePhoneSize)
  3307.                         {
  3308.                             DeletePhonebook(PrivatePhonebook,PrivatePhoneSize,TRUE);
  3309.  
  3310.                             Success = FALSE;
  3311.                         }
  3312.                     }
  3313.                 }
  3314.  
  3315.                 CloseIFF(Handle);
  3316.             }
  3317.  
  3318.             Close(Handle -> iff_Stream);
  3319.         }
  3320.         else
  3321.             Error = IoErr();
  3322.  
  3323.         FreeIFF(Handle);
  3324.     }
  3325.     else
  3326.         Error = ERR_NO_MEM;
  3327.  
  3328.     if(Error)
  3329.         SetIoErr(Error);
  3330.  
  3331.     if(UseOld)
  3332.         return(LoadOldPhonebook(Name,BookHandle));
  3333.     else
  3334.         return(Success);
  3335. }
  3336.  
  3337.     /* WriteConfig(STRPTR Name,struct Configuration *Config):
  3338.      *
  3339.      *    Write the configuration to a file, very much like
  3340.      *    WriteIFFData().
  3341.      */
  3342.  
  3343. BYTE __regargs
  3344. WriteConfig(STRPTR Name,struct Configuration *Config)
  3345. {
  3346.     struct IFFHandle    *Handle;
  3347.     BYTE                 Success = FALSE;
  3348.     LONG                 Error = 0;
  3349.  
  3350.         /* Allocate a handle. */
  3351.  
  3352.     if(Handle = AllocIFF())
  3353.     {
  3354.             /* Open an output stream. */
  3355.  
  3356.         if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  3357.         {
  3358.                 /* Tell iffparse that this is
  3359.                  * a DOS handle.
  3360.                  */
  3361.  
  3362.             InitIFFasDOS(Handle);
  3363.  
  3364.                 /* Open the handle for writing. */
  3365.  
  3366.             if(!(Error = OpenIFF(Handle,IFFF_WRITE)))
  3367.             {
  3368.                     /* Push outmost chunk onto stack. */
  3369.  
  3370.                 if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  3371.                 {
  3372.                         /* Add a version identifier. */
  3373.  
  3374.                     if(!(Error = PushChunk(Handle,0,ID_VERS,IFFSIZE_UNKNOWN)))
  3375.                     {
  3376.                         struct TermInfo TermInfo;
  3377.  
  3378.                         TermInfo . Version    = CONFIG_FILE_VERSION;
  3379.                         TermInfo . Revision    = CONFIG_FILE_REVISION;
  3380.  
  3381.                             /* Update the other configuration pointer as well. */
  3382.  
  3383.                         Config -> SerialConfig -> LastVersionSaved    = TermVersion;
  3384.                         Config -> SerialConfig -> LastRevisionSaved    = TermRevision;
  3385.  
  3386.                             /* Write the version data. */
  3387.  
  3388.                         if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  3389.                         {
  3390.                                 /* Pop the version chunk, i.e. write it to the file. */
  3391.  
  3392.                             if(Error = PopChunk(Handle))
  3393.                                 Success = FALSE;
  3394.                             else
  3395.                             {
  3396.                                 if(WriteConfigChunks(Handle,Config,NULL,NULL))
  3397.                                 {
  3398.                                     LONG i;
  3399.  
  3400.                                     Success = TRUE;
  3401.  
  3402.                                     for(i = 0 ; Success && i < WINDOW_COUNT ; i++)
  3403.                                     {
  3404.                                         if(!(Error = PushChunk(Handle,0,ID_WINF,sizeof(struct WindowInfo))))
  3405.                                         {
  3406.                                             if(WriteChunkBytes(Handle,&WindowInfoTable[i],sizeof(struct WindowInfo)) == sizeof(struct WindowInfo))
  3407.                                             {
  3408.                                                 if(Error = PopChunk(Handle))
  3409.                                                     Success = FALSE;
  3410.                                             }
  3411.                                             else
  3412.                                             {
  3413.                                                 Error = IoErr();
  3414.  
  3415.                                                 Success = FALSE;
  3416.                                             }
  3417.                                         }
  3418.                                         else
  3419.                                             Success = FALSE;
  3420.                                     }
  3421.                                 }
  3422.                             }
  3423.                         }
  3424.                         else
  3425.                         {
  3426.                             Error = IoErr();
  3427.  
  3428.                             Success = FALSE;
  3429.                         }
  3430.                     }
  3431.  
  3432.                         /* Seems that we're done, now try to pop the FORM chunk
  3433.                          * and return.
  3434.                          */
  3435.  
  3436.                     if(Success)
  3437.                     {
  3438.                         if(Error = PopChunk(Handle))
  3439.                             Success = FALSE;
  3440.                     }
  3441.                 }
  3442.  
  3443.                     /* Close the handle (flush any pending data). */
  3444.  
  3445.                 CloseIFF(Handle);
  3446.             }
  3447.  
  3448.                 /* Close the DOS handle itself. */
  3449.  
  3450.             Close(Handle -> iff_Stream);
  3451.         }
  3452.         else
  3453.             Error = IoErr();
  3454.  
  3455.             /* And free the IFF handle. */
  3456.  
  3457.         FreeIFF(Handle);
  3458.     }
  3459.     else
  3460.         Error = ERR_NO_MEM;
  3461.  
  3462.     if(Success)
  3463.         AddProtection(Name,FIBF_EXECUTE);
  3464.  
  3465.     return(Success);
  3466. }
  3467.  
  3468.     /* ReadConfig(STRPTR Name,struct Configuration *Config):
  3469.      *
  3470.      *    Read the configuration file, very much the same as ReadIFFData().
  3471.      */
  3472.  
  3473. BYTE __regargs
  3474. ReadConfig(STRPTR Name,struct Configuration *Config)
  3475. {
  3476.     struct IFFHandle    *Handle;
  3477.     BYTE                 Success    = FALSE,
  3478.                          UseOld        = FALSE;
  3479.     struct ContextNode    *Chunk;
  3480.     UBYTE                 ConfigChunkType;
  3481.     LONG                 Error = 0;
  3482.  
  3483.     if(Handle = AllocIFF())
  3484.     {
  3485.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  3486.         {
  3487.             InitIFFasDOS(Handle);
  3488.  
  3489.             if(!(Error = OpenIFF(Handle,IFFF_READ)))
  3490.             {
  3491.                 if(!StopChunks(Handle,Stops,NUM_STOPS))
  3492.                 {
  3493.                     struct TermInfo TermInfo;
  3494.  
  3495.                     while(!ParseIFF(Handle,IFFPARSE_SCAN))
  3496.                     {
  3497.                         Chunk = CurrentChunk(Handle);
  3498.  
  3499.                             /* Oops! Some is trying to
  3500.                              * use the phone book file as
  3501.                              * a configuration file.
  3502.                              */
  3503.  
  3504.                         if(Chunk -> cn_ID == ID_CAT)
  3505.                         {
  3506.                             Success = FALSE;
  3507.  
  3508.                             break;
  3509.                         }
  3510.  
  3511.                         if(Chunk -> cn_ID == ID_VERS)
  3512.                         {
  3513.                             if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  3514.                             {
  3515.                                 if(TermInfo . Version != CONFIG_FILE_VERSION || (TermInfo . Version == CONFIG_FILE_VERSION && TermInfo . Revision > CONFIG_FILE_REVISION))
  3516.                                 {
  3517.                                     if(TermInfo . Version == 2 && TermInfo . Revision == 4)
  3518.                                         UseOld = TRUE;
  3519.  
  3520.                                     if(TermInfo . Version != 3)
  3521.                                         break;
  3522.                                 }
  3523.                             }
  3524.                             else
  3525.                             {
  3526.                                 Error = IoErr();
  3527.  
  3528.                                 break;
  3529.                             }
  3530.                         }
  3531.  
  3532.                         if(Chunk -> cn_ID == ID_WINF)
  3533.                         {
  3534.                             struct WindowInfo Info;
  3535.  
  3536.                             if(ReadChunkBytes(Handle,&Info,sizeof(Info)) == sizeof(Info))
  3537.                             {
  3538.                                 Success = TRUE;
  3539.  
  3540.                                 ReplaceWindowInfo(&Info);
  3541.                             }
  3542.                             else
  3543.                             {
  3544.                                 Error = IoErr();
  3545.  
  3546.                                 Success = FALSE;
  3547.                                 break;
  3548.                             }
  3549.                         }
  3550.                         else
  3551.                         {
  3552.                             if(ConfigChunkType = IsConfigChunk(Chunk -> cn_ID))
  3553.                             {
  3554.                                 if(ReadConfigChunk(Handle,Config,ConfigChunkType,Chunk -> cn_Size,NULL))
  3555.                                 {
  3556.                                     FixOldConfig(Config,ConfigChunkType,FALSE,TermInfo . Version,TermInfo . Revision);
  3557.  
  3558.                                     Success = TRUE;
  3559.                                 }
  3560.                                 else
  3561.                                 {
  3562.                                     Error = IoErr();
  3563.  
  3564.                                     Success = FALSE;
  3565.  
  3566.                                     break;
  3567.                                 }
  3568.                             }
  3569.  
  3570.                                 // Special treatment for obsolete "FILE" chunk
  3571.  
  3572.                             if(Chunk -> cn_ID == ID_FILE)
  3573.                             {
  3574.                                 struct Configuration *LocalConfig = Config;
  3575.                                 LONG i;
  3576.  
  3577.                                 for(i = PREF_TRANSLATIONFILENAME ; i <= PREF_FASTMACROFILENAME ; i++)
  3578.                                 {
  3579.                                     if(!CreateConfigEntry(LocalConfig,i))
  3580.                                     {
  3581.                                         Error = ERROR_NO_FREE_STORE;
  3582.  
  3583.                                         Success = FALSE;
  3584.  
  3585.                                         break;
  3586.                                     }
  3587.                                 }
  3588.  
  3589.                                 if(!Error)
  3590.                                 {
  3591.                                     strcpy(LocalConfig -> TranslationFileName,    LocalConfig -> FileConfig -> TranslationFileName);
  3592.                                     strcpy(LocalConfig -> MacroFileName,        LocalConfig -> FileConfig -> MacroFileName);
  3593.                                     strcpy(LocalConfig -> CursorFileName,        LocalConfig -> FileConfig -> CursorFileName);
  3594.                                     strcpy(LocalConfig -> FastMacroFileName,    LocalConfig -> FileConfig -> FastMacroFileName);
  3595.  
  3596.                                     DeleteConfigEntry(LocalConfig,PREF_FILE);
  3597.                                 }
  3598.                             }
  3599.                         }
  3600.                     }
  3601.  
  3602.                     if(Success)
  3603.                         FinalFix(Config,FALSE,TermInfo . Version,TermInfo . Revision);
  3604.                 }
  3605.  
  3606.                 CloseIFF(Handle);
  3607.             }
  3608.  
  3609.             Close(Handle -> iff_Stream);
  3610.         }
  3611.  
  3612.         FreeIFF(Handle);
  3613.     }
  3614.     else
  3615.         Error = IoErr();
  3616.  
  3617.     if(Error)
  3618.         SetIoErr(Error);
  3619.  
  3620.     if(UseOld)
  3621.         return(ReadOldConfig(Name,Config));
  3622.     else
  3623.         return(Success);
  3624. }
  3625.